Merge pull request #2384 from swiftwasm/main

[pull] swiftwasm from main

Author: MaxDesiatov

include/swift/SIL/SILFunction.h

@@ -1106,7 +1106,7 @@ class SILFunction
   /// NOTE: The ownership verifier is always run when performing normal IR
   /// verification, so this verification can be viewed as a subset of
   /// SILFunction::verify.
-  void verifyOwnership(DeadEndBlocks *deadEndBlocks = nullptr) const;
+  void verifyOwnership(DeadEndBlocks *deadEndBlocks) const;
 
   /// Verify that all non-cond-br critical edges have been split.
   ///

include/swift/SIL/SILValue.h

@@ -571,7 +571,7 @@ class SILValue {
   ValueOwnershipKind getOwnershipKind() const;
 
   /// Verify that this SILValue and its uses respects ownership invariants.
-  void verifyOwnership(DeadEndBlocks *DEBlocks = nullptr) const;
+  void verifyOwnership(DeadEndBlocks *DEBlocks) const;
 };
 
 inline bool ValueOwnershipKind::isCompatibleWith(SILValue other) const {

lib/AST/ASTDumper.cpp

@@ -772,14 +772,14 @@ namespace {
       }
 
       auto VarD = dyn_cast<VarDecl>(VD);
-      if (VD->isFinal() && !(VarD && VarD->isLet()))
+      const auto &attrs = VD->getAttrs();
+      if (attrs.hasAttribute<FinalAttr>() && !(VarD && VarD->isLet()))
         OS << " final";
-      if (VD->getAttrs().hasAttribute<ObjCAttr>())
+      if (attrs.hasAttribute<ObjCAttr>())
         OS << " @objc";
-      if (VD->getAttrs().hasAttribute<DynamicAttr>())
+      if (attrs.hasAttribute<DynamicAttr>())
         OS << " dynamic";
-      if (auto *attr =
-              VD->getAttrs().getAttribute<DynamicReplacementAttr>()) {
+      if (auto *attr = attrs.getAttribute<DynamicReplacementAttr>()) {
         OS << " @_dynamicReplacement(for: \"";
         OS << attr->getReplacedFunctionName();
         OS << "\")";

lib/SIL/Verifier/SILOwnershipVerifier.cpp

@@ -772,16 +772,9 @@ verifySILValueHelper(const SILFunction *f, SILValue value,
     return;
 
   SmallPtrSet<SILBasicBlock *, 32> liveBlocks;
-  if (deadEndBlocks) {
-    SILValueOwnershipChecker(*deadEndBlocks, value, errorBuilder, liveBlocks,
-                             reborrowVerifier)
-        .check();
-  } else {
-    DeadEndBlocks deadEndBlocks(f);
-    SILValueOwnershipChecker(deadEndBlocks, value, errorBuilder, liveBlocks,
-                             reborrowVerifier)
-        .check();
-  }
+  SILValueOwnershipChecker(*deadEndBlocks, value, errorBuilder, liveBlocks,
+                           reborrowVerifier)
+    .check();
 }
 
 void SILValue::verifyOwnership(DeadEndBlocks *deadEndBlocks) const {

lib/SILOptimizer/SILCombiner/SILCombine.cpp

@@ -138,7 +138,7 @@ class SILCombineCanonicalize final : CanonicalizeInstruction {
     changed = true;
   }
 
-  bool tryCanonicalize(SILInstruction *inst, DeadEndBlocks &deadEndBlocks) {
+  bool tryCanonicalize(SILInstruction *inst) {
     changed = false;
     canonicalize(inst);
     return changed;
@@ -178,7 +178,7 @@ bool SILCombiner::doOneIteration(SILFunction &F, unsigned Iteration) {
     }
 
     // Canonicalize the instruction.
-    if (scCanonicalize.tryCanonicalize(I, deadEndBlocks)) {
+    if (scCanonicalize.tryCanonicalize(I)) {
       MadeChange = true;
       continue;
     }

lib/SILOptimizer/SILCombiner/SILCombinerMiscVisitors.cpp

@@ -1849,17 +1849,17 @@ SILInstruction *SILCombiner::visitTupleExtractInst(TupleExtractInst *TEI) {
   return nullptr;
 }
 
-SILInstruction *SILCombiner::visitFixLifetimeInst(FixLifetimeInst *FLI) {
-  if (FLI->getFunction()->hasOwnership())
-    return nullptr;
-
+SILInstruction *SILCombiner::visitFixLifetimeInst(FixLifetimeInst *fli) {
   // fix_lifetime(alloc_stack) -> fix_lifetime(load(alloc_stack))
-  Builder.setCurrentDebugScope(FLI->getDebugScope());
-  if (auto *AI = dyn_cast<AllocStackInst>(FLI->getOperand())) {
-    if (FLI->getOperand()->getType().isLoadable(*FLI->getFunction())) {
-      auto Load = Builder.createLoad(FLI->getLoc(), AI,
-                                     LoadOwnershipQualifier::Unqualified);
-      return Builder.createFixLifetime(FLI->getLoc(), Load);
+  Builder.setCurrentDebugScope(fli->getDebugScope());
+  if (auto *ai = dyn_cast<AllocStackInst>(fli->getOperand())) {
+    if (fli->getOperand()->getType().isLoadable(*fli->getFunction())) {
+      // load when ossa is disabled
+      auto load = Builder.emitLoadBorrowOperation(fli->getLoc(), ai);
+      Builder.createFixLifetime(fli->getLoc(), load);
+      // no-op when ossa is disabled
+      Builder.emitEndBorrowOperation(fli->getLoc(), load);
+      return eraseInstFromFunction(*fli);
     }
   }
   return nullptr;

stdlib/public/SwiftShims/RefCount.h

@@ -793,6 +793,7 @@ class RefCounts {
   }
 
   // Increment the reference count.
+  SWIFT_ALWAYS_INLINE
   void increment(uint32_t inc = 1) {
     auto oldbits = refCounts.load(SWIFT_MEMORY_ORDER_CONSUME);
 
@@ -815,6 +816,7 @@ class RefCounts {
                                               std::memory_order_relaxed));
   }
 
+  SWIFT_ALWAYS_INLINE
   void incrementNonAtomic(uint32_t inc = 1) {
     auto oldbits = refCounts.load(SWIFT_MEMORY_ORDER_CONSUME);
 
@@ -835,6 +837,7 @@ class RefCounts {
  }
 
   // Increment the reference count, unless the object is deiniting.
+  SWIFT_ALWAYS_INLINE
   bool tryIncrement() {
     auto oldbits = refCounts.load(SWIFT_MEMORY_ORDER_CONSUME);
     RefCountBits newbits;
@@ -854,6 +857,7 @@ class RefCounts {
     return true;
   }
 
+  SWIFT_ALWAYS_INLINE
   bool tryIncrementNonAtomic() {
     auto oldbits = refCounts.load(SWIFT_MEMORY_ORDER_CONSUME);
     if (!oldbits.hasSideTable() && oldbits.getIsDeiniting())
@@ -896,6 +900,7 @@ class RefCounts {
   // object as deiniting.
   //
   // Precondition: the reference count must be 1
+  SWIFT_ALWAYS_INLINE
   void decrementFromOneNonAtomic() {
     auto bits = refCounts.load(SWIFT_MEMORY_ORDER_CONSUME);
     if (bits.isImmortal(true)) {
@@ -1078,6 +1083,7 @@ class RefCounts {
   // Deinit is optionally handled directly instead of always deferring to 
   // the caller because the compiler can optimize this arrangement better.
   template <PerformDeinit performDeinit>
+  SWIFT_ALWAYS_INLINE
   bool doDecrement(uint32_t dec) {
     auto oldbits = refCounts.load(SWIFT_MEMORY_ORDER_CONSUME);
     RefCountBits newbits;

stdlib/public/SwiftShims/SwiftStddef.h

@@ -17,15 +17,22 @@
 // result, using stddef.h here would pull in Darwin module (which includes
 // libc). This creates a dependency cycle, so we can't use stddef.h in
 // SwiftShims.
+//
 // On Linux, the story is different. We get the error message
 // "/usr/include/x86_64-linux-gnu/sys/types.h:146:10: error: 'stddef.h' file not
 // found"
 // This is a known Clang/Ubuntu bug.
-#if !defined(__APPLE__) && !defined(__linux__)
+//
+// On Windows, the complicated setup between clang and MSVC causes a cicular
+// dependency between `ucrt` and `SwiftShims`, preventing a successful build of
+// the module.
+//
+// Opt to use teh compiler vended type whenever possible.
+#if defined(__clang__)
+typedef __SIZE_TYPE__ __swift_size_t;
+#else
 #include <stddef.h>
 typedef size_t __swift_size_t;
-#else
-typedef __SIZE_TYPE__ __swift_size_t;
 #endif
 
 // This selects the signed equivalent of the unsigned type chosen for size_t.

stdlib/public/runtime/HeapObject.cpp

@@ -60,6 +60,7 @@ using namespace swift;
 
 /// Returns true if the pointer passed to a native retain or release is valid.
 /// If false, the operation should immediately return.
+SWIFT_ALWAYS_INLINE
 static inline bool isValidPointerForNativeRetain(const void *p) {
 #if defined(__x86_64__) || defined(__arm64__) || defined(__aarch64__) || defined(_M_ARM64) || defined(__s390x__) || (defined(__powerpc64__) && defined(__LITTLE_ENDIAN__))
   // On these platforms, except s390x, the upper half of address space is reserved for the
@@ -332,6 +333,7 @@ HeapObject *swift::swift_allocEmptyBox() {
 extern "C" SWIFT_LIBRARY_VISIBILITY SWIFT_NOINLINE SWIFT_USED void
 _swift_release_dealloc(HeapObject *object);
 
+SWIFT_ALWAYS_INLINE
 static HeapObject *_swift_retain_(HeapObject *object) {
   SWIFT_RT_TRACK_INVOCATION(object, swift_retain);
   if (isValidPointerForNativeRetain(object))
@@ -358,6 +360,7 @@ HeapObject *swift::swift_nonatomic_retain(HeapObject *object) {
   return object;
 }
 
+SWIFT_ALWAYS_INLINE
 static HeapObject *_swift_retain_n_(HeapObject *object, uint32_t n) {
   SWIFT_RT_TRACK_INVOCATION(object, swift_retain_n);
   if (isValidPointerForNativeRetain(object))
@@ -384,6 +387,7 @@ HeapObject *swift::swift_nonatomic_retain_n(HeapObject *object, uint32_t n) {
   return object;
 }
 
+SWIFT_ALWAYS_INLINE
 static void _swift_release_(HeapObject *object) {
   SWIFT_RT_TRACK_INVOCATION(object, swift_release);
   if (isValidPointerForNativeRetain(object))
@@ -408,6 +412,7 @@ void swift::swift_nonatomic_release(HeapObject *object) {
     object->refCounts.decrementAndMaybeDeinitNonAtomic(1);
 }
 
+SWIFT_ALWAYS_INLINE
 static void _swift_release_n_(HeapObject *object, uint32_t n) {
   SWIFT_RT_TRACK_INVOCATION(object, swift_release_n);
   if (isValidPointerForNativeRetain(object))
@@ -567,6 +572,7 @@ void swift::swift_nonatomic_unownedRelease_n(HeapObject *object, int n) {
   }
 }
 
+SWIFT_ALWAYS_INLINE
 static HeapObject *_swift_tryRetain_(HeapObject *object) {
   SWIFT_RT_TRACK_INVOCATION(object, swift_tryRetain);
   if (!isValidPointerForNativeRetain(object))

test/Driver/Dependencies/Inputs/bindings-build-record/added.swift

@@ -1,2 +1 @@
-# Dependencies after compilation:
-depends-nominal: [z]
+