[silgen] Change SILGen to emit ignored_user for emitIgnoredExpr and black hole initialization.

Author: gottesmm

lib/SIL/Verifier/SILVerifier.cpp

@@ -719,6 +719,7 @@ struct ImmutableAddressUseVerifier {
       case SILInstructionKind::KeyPathInst:
       case SILInstructionKind::SwitchEnumAddrInst:
       case SILInstructionKind::SelectEnumAddrInst:
+      case SILInstructionKind::IgnoredUseInst:
         break;
       case SILInstructionKind::DebugValueInst:
         if (cast<DebugValueInst>(inst)->hasAddrVal())

lib/SILGen/SILGenDecl.cpp

@@ -1582,38 +1582,34 @@ void SILGenFunction::emitPatternBinding(PatternBindingDecl *PBD, unsigned idx,
     return nullptr;
   };
 
-  auto emitInitializer = [&](Expr *initExpr, VarDecl *var, bool forLocalContext,
-                             InitializationPtr &initialization) {
-    // If an initial value expression was specified by the decl, emit it into
-    // the initialization.
-    FullExpr Scope(Cleanups, CleanupLocation(initExpr));
-
-    if (forLocalContext) {
-      if (auto *orig = var->getOriginalWrappedProperty()) {
-        if (auto *initExpr = getWrappedValueExpr(var)) {
-          auto value = emitRValue(initExpr);
-          emitApplyOfPropertyWrapperBackingInitializer(
+  auto *initExpr = PBD->getExecutableInit(idx);
+
+  // If we do not have an explicit initialization expression, just mark the
+  // initialization as unfinished for DI to resolve.
+  if (!initExpr) {
+    return initialization->finishUninitialized(*this);
+  }
+
+  // Otherwise, an initial value expression was specified by the decl... emit it
+  // into the initialization.
+  FullExpr Scope(Cleanups, CleanupLocation(initExpr));
+
+  auto *singleVar = PBD->getSingleVar();
+  bool isLocalSingleVar =
+      singleVar && singleVar->getDeclContext()->isLocalContext();
+  if (isLocalSingleVar) {
+    if (auto *orig = singleVar->getOriginalWrappedProperty()) {
+      if (auto *initExpr = getWrappedValueExpr(singleVar)) {
+        auto value = emitRValue(initExpr);
+        emitApplyOfPropertyWrapperBackingInitializer(
             PBD, orig, getForwardingSubstitutionMap(), std::move(value))
             .forwardInto(*this, SILLocation(PBD), initialization.get());
-          return;
-        }
+        return;
       }
     }
-
-    emitExprInto(initExpr, initialization.get());
-  };
-
-  auto *singleVar = PBD->getSingleVar();
-  if (auto *Init = PBD->getExecutableInit(idx)) {
-    // If an initial value expression was specified by the decl, emit it into
-    // the initialization.
-    bool isLocalVar =
-        singleVar && singleVar->getDeclContext()->isLocalContext();
-    emitInitializer(Init, singleVar, isLocalVar, initialization);
-  } else {
-    // Otherwise, mark it uninitialized for DI to resolve.
-    initialization->finishUninitialized(*this);
   }
+
+  emitExprInto(initExpr, initialization.get());
 }
 
 void SILGenFunction::visitPatternBindingDecl(PatternBindingDecl *PBD,
@@ -2421,18 +2417,23 @@ void BlackHoleInitialization::performPackExpansionInitialization(
 
 void BlackHoleInitialization::copyOrInitValueInto(SILGenFunction &SGF, SILLocation loc,
                                                   ManagedValue value, bool isInit) {
-  // Normally we do not do anything if we have a black hole
-  // initialization... but if we have a move only object, insert a move value.
-  if (!value.getType().isMoveOnly())
+  // If we do not have a noncopyable type, just insert an ignored use.
+  if (!value.getType().isMoveOnly()) {
+    SGF.B.createIgnoredUse(loc, value.getValue());
     return;
+  }
 
-  // If we have an address, then this will create a new temporary allocation
-  // which will trigger the move checker. If we have an object though, we need
-  // to insert an extra move_value to make sure the object checker behaves
-  // correctly.
+  // If we have a noncopyable type, we need to do a little more work to satisfy
+  // the move checkers. If we have an address, then this will create a new
+  // temporary allocation which will trigger the move checker...
   value = value.ensurePlusOne(SGF, loc);
-  if (value.getType().isAddress())
+  if (value.getType().isAddress()) {
+    SGF.B.createIgnoredUse(loc, value.getValue());
     return;
+  }
 
+  // If we have an object though, we need to insert an extra move_value to make
+  // sure the object checker behaves correctly.
   value = SGF.B.createMoveValue(loc, value);
+  SGF.B.createIgnoredUse(loc, value.getValue());
 }

lib/SILGen/SILGenExpr.cpp

@@ -5376,7 +5376,19 @@ static void emitSimpleAssignment(SILGenFunction &SGF, SILLocation loc,
           value = value.ensurePlusOne(SGF, loc);
           if (value.getType().isObject())
             value = SGF.B.createMoveValue(loc, value);
+          SGF.B.createIgnoredUse(loc, value.getValue());
+          return;
+        }
+
+        // Emit the ignored use instruction like we would do in emitIgnoredExpr.
+        if (!rv.isNull()) {
+          SmallVector<ManagedValue, 16> values;
+          std::move(rv).getAll(values);
+          for (auto v : values) {
+            SGF.B.createIgnoredUse(loc, v.getValue());
+          }
         }
+
         return;
       }
 
@@ -7027,7 +7039,24 @@ void SILGenFunction::emitIgnoredExpr(Expr *E) {
 
   // Otherwise, emit the result (to get any side effects), but produce it at +0
   // if that allows simplification.
-  emitRValue(E, SGFContext::AllowImmediatePlusZero);
+  RValue rv = emitRValue(E, SGFContext::AllowImmediatePlusZero);
+
+  // Return early if we do not have any result.
+  if (rv.isNull())
+    return;
+
+  // Then emit ignored use on all of the rvalue components. We purposely do not
+  // implode the tuple since if we have a tuple formation like:
+  //
+  // let _ = (x, y)
+  //
+  // we want the use to be on x and y and not on the imploded tuple. It also
+  // helps us avoid emitting unnecessary code.
+  SmallVector<ManagedValue, 16> values;
+  std::move(rv).getAll(values);
+  for (auto v : values) {
+    B.createIgnoredUse(E, v.getValue());
+  }
 }
 
 /// Emit the given expression as an r-value, then (if it is a tuple), combine

lib/SILOptimizer/Mandatory/DiagnoseUnreachable.cpp

@@ -775,6 +775,14 @@ static bool simplifyBlocksWithCallsToNoReturn(SILBasicBlock &BB,
     if (isa<EndBorrowInst>(currInst))
       return false;
 
+    // If we have an ignored use whose operand is our no return call, ignore it.
+    if (auto *i = dyn_cast<IgnoredUseInst>(currInst)) {
+      if (auto *svi = dyn_cast<SingleValueInstruction>(i->getOperand());
+          svi && getAsCallToNoReturn(svi)) {
+        return false;
+      }
+    }
+
     // destroy_value [dead_end] instructions are inserted at the availability
     // boundary by lifetime completion.  Such instructions correctly mark the
     // lifetime boundary of the destroyed value and never arise from dead user

lib/SILOptimizer/Mandatory/LowerTupleAddrConstructor.cpp

@@ -78,46 +78,53 @@ class LowerTupleAddrConstructorTransform : public SILFunctionTransform {
     bool deletedInst = false;
     for (auto &block : *function) {
       for (auto ii = block.begin(), ie = block.end(); ii != ie;) {
-        auto *inst = dyn_cast<TupleAddrConstructorInst>(&*ii);
+        auto *inst = &*ii;
         ++ii;
 
-        if (!inst)
+        if (auto *i = dyn_cast<IgnoredUseInst>(inst)) {
+          i->eraseFromParent();
+          deletedInst = true;
+          continue;
+        }
+
+        auto *t = dyn_cast<TupleAddrConstructorInst>(inst);
+        if (!t)
           continue;
 
         // (tuple_addr_constructor [assign/init] %addr,
         //                         (destructure_tuple %tuple))
         // ->
         // (store [assign/init] %tuple to %addr)
-        if (peepholeTupleDestructorOperand(inst)) {
+        if (peepholeTupleDestructorOperand(t)) {
           continue;
         }
 
         SILBuilderWithScope builder(inst);
 
         unsigned count = 0;
         visitExplodedTupleValue(
-            inst->getDest(),
+            t->getDest(),
             [&](SILValue value, std::optional<unsigned> index) -> SILValue {
               if (!index) {
-                SILValue elt = inst->getElement(count);
+                SILValue elt = t->getElement(count);
                 if (elt->getType().isAddress()) {
-                  builder.createCopyAddr(inst->getLoc(), elt, value, IsTake,
-                                         inst->isInitializationOfDest());
+                  builder.createCopyAddr(t->getLoc(), elt, value, IsTake,
+                                         t->isInitializationOfDest());
                 } else {
                   builder.emitStoreValueOperation(
-                      inst->getLoc(), elt, value,
-                      bool(inst->isInitializationOfDest())
+                      t->getLoc(), elt, value,
+                      bool(t->isInitializationOfDest())
                           ? StoreOwnershipQualifier::Init
                           : StoreOwnershipQualifier::Assign);
                 }
                 ++count;
                 return value;
               }
               auto *teai =
-                  builder.createTupleElementAddr(inst->getLoc(), value, *index);
+                  builder.createTupleElementAddr(t->getLoc(), value, *index);
               return teai;
             });
-        inst->eraseFromParent();
+        t->eraseFromParent();
         deletedInst = true;
       }
     }

lib/SILOptimizer/Mandatory/MoveOnlyWrappedTypeEliminator.cpp

@@ -210,6 +210,7 @@ struct SILMoveOnlyWrappedTypeEliminatorVisitor
   NO_UPDATE_NEEDED(AddressToPointer)
   NO_UPDATE_NEEDED(ExistentialMetatype)
   NO_UPDATE_NEEDED(Builtin)
+  NO_UPDATE_NEEDED(IgnoredUse)
 #undef NO_UPDATE_NEEDED
 
   bool eliminateIdentityCast(SingleValueInstruction *svi) {

lib/SILOptimizer/Mandatory/OwnershipModelEliminator.cpp

@@ -139,6 +139,11 @@ struct OwnershipModelEliminatorVisitor
   bool visitExplicitCopyAddrInst(ExplicitCopyAddrInst *cai);
   bool visitApplyInst(ApplyInst *ai);
 
+  bool visitIgnoredUseInst(IgnoredUseInst *iui) {
+    eraseInstruction(iui);
+    return true;
+  }
+
   void splitDestroy(DestroyValueInst *destroy);
   bool peepholeTupleConstructorUser(DestructureTupleInst *dti);
   bool visitDestroyValueInst(DestroyValueInst *dvi);

test/AutoDiff/SILOptimizer/activity_analysis.swift

@@ -191,7 +191,7 @@ func checked_cast_addr_nonactive_result<T: Differentiable>(_ x: T) -> T {
 // CHECK: bb5:
 // CHECK: [VARIED] %18 = argument of bb5 : $Float
 // CHECK: bb6:
-// CHECK: [NONE]   %22 = tuple ()
+// CHECK: [NONE]   %{{.*}} = tuple ()
 
 // CHECK-LABEL: sil hidden [ossa] @${{.*}}checked_cast_addr_nonactive_result{{.*}} : $@convention(thin) <T where T : Differentiable> (@in_guaranteed T) -> @out T {
 // CHECK:   checked_cast_addr_br take_always T in %3 : $*T to Float in %5 : $*Float, bb1, bb2

test/Concurrency/transfernonsendable.swift

@@ -887,8 +887,8 @@ func letSendableNonTrivialLetStructFieldTest() async {
   await transferToMain(test) // expected-tns-warning {{sending 'test' risks causing data races}}
   // expected-tns-note @-1 {{sending 'test' to main actor-isolated global function 'transferToMain' risks causing data races between main actor-isolated and local nonisolated uses}}
   // expected-complete-warning @-2 {{passing argument of non-sendable type 'StructFieldTests' into main actor-isolated context may introduce data races}}
-  _ = test.letSendableNonTrivial
-  useValue(test) // expected-tns-note {{access can happen concurrently}}
+  _ = test.letSendableNonTrivial // expected-tns-note {{access can happen concurrently}}
+  useValue(test)
 }
 
 func letNonSendableNonTrivialLetStructFieldTest() async {
@@ -968,8 +968,8 @@ func varSendableNonTrivialLetStructFieldTest() async {
   await transferToMain(test) // expected-tns-warning {{sending 'test' risks causing data races}}
   // expected-tns-note @-1 {{sending 'test' to main actor-isolated global function 'transferToMain' risks causing data races between main actor-isolated and local nonisolated uses}}
   // expected-complete-warning @-2 {{passing argument of non-sendable type 'StructFieldTests' into main actor-isolated context may introduce data races}}
-  _ = test.varSendableNonTrivial
-  useValue(test) // expected-tns-note {{access can happen concurrently}}
+  _ = test.varSendableNonTrivial // expected-tns-note {{access can happen concurrently}}
+  useValue(test)
 }
 
 func varNonSendableNonTrivialLetStructFieldTest() async {

test/SILGen/class_bound_protocols.swift

@@ -198,6 +198,7 @@ func takesInheritsMutatingMethod(x: inout InheritsMutatingMethod,
   // CHECK-NEXT: end_borrow
   // CHECK-NEXT: destroy_addr
   // CHECK-NEXT: end_access [[X_ADDR]] : $*any InheritsMutatingMethod
+  // CHECK-NEXT: ignored_use [[RESULT_VALUE]]
   // CHECK-NEXT: dealloc_stack [[TEMPORARY]] : $*@opened("{{.*}}", any InheritsMutatingMethod) Self
   _ = x.mutatingCounter