[move-only] If we have a noncopyable type on an alloc_stack/alloc_box/debug_value, set the [moveable_value_debuginfo] flag.

This still does not have the complete behavior that we want since we are not yet
inserting the debug_value undef to invalidate after performing moves.

NOTE: In printed SIL, I decided to make the flag implicit if we have a
noncopyable type. This is just to reduce the bloat in SIL. If one needs this
property for a copyable type though, it is mandatory.

Author: gottesmm

docs/SIL.rst

@@ -3770,10 +3770,11 @@ This is the case, e.g. for conditionally initialized objects.
 The optional ``lexical`` attribute specifies that the storage corresponds to a
 local variable in the Swift source.
 
-The optional ``moveable_value_debuginfo`` attribute specifies that when
-emitting debug info, the code generator can not assume that the value in the
-alloc_stack can be semantically valid over the entire function frame when
-emitting debug info.
+The optional ``moveable_value_debuginfo`` attribute specifies that when emitting
+debug info, the code generator can not assume that the value in the alloc_stack
+can be semantically valid over the entire function frame when emitting debug
+info. NOTE: This is implicitly set to true if the alloc_stack's type is
+noncopyable. This is just done to make SIL less verbose.
 
 The memory is not retainable. To allocate a retainable box for a value
 type, use ``alloc_box``.
@@ -3886,10 +3887,11 @@ Releasing a box is undefined behavior if the box's value is uninitialized.
 To deallocate a box whose value has not been initialized, ``dealloc_box``
 should be used.
 
-The optional ``moveable_value_debuginfo`` attribute specifies that when
-emitting debug info, the code generator can not assume that the value in the
-alloc_stack can be semantically valid over the entire function frame when
-emitting debug info.
+The optional ``moveable_value_debuginfo`` attribute specifies that when emitting
+debug info, the code generator can not assume that the value in the alloc_stack
+can be semantically valid over the entire function frame when emitting debug
+info. NOTE: This is implicitly set to true if the alloc_stack's type is
+noncopyable. This is just done to make SIL less verbose.
 
 alloc_global
 ````````````
@@ -4163,7 +4165,10 @@ debug_value
 
 ::
 
-  sil-instruction ::= debug_value '[poison]'? '[moveable_value_debuginfo]'? '[trace]'? sil-operand (',' debug-var-attr)* advanced-debug-var-attr* (',' 'expr' debug-info-expr)?
+  sil-instruction ::= debug_value sil-debug-value-option* sil-operand (',' debug-var-attr)* advanced-debug-var-attr* (',' 'expr' debug-info-expr)?
+  sil-debug-value-option ::= [poison]
+  sil-debug-value-option ::= [moveable_value_debuginfo]
+  sil-debug-value-option ::= [trace]
 
   debug_value %1 : $Int
 
@@ -4172,10 +4177,12 @@ specified operand.  The declaration in question is identified by either the
 SILLocation attached to the debug_value instruction or the SILLocation specified
 in the advanced debug variable attributes.
 
-If the '[moveable_value_debuginfo]' flag is set, then one knows that the debug_value's operand is
-moved at some point of the program, so one can not model the debug_value using
-constructs that assume that the value is live for the entire function (e.x.:
-llvm.dbg.declare).
+If the ``moveable_value_debuginfo`` flag is set, then one knows that the
+debug_value's operand is moved at some point of the program, so one can not
+model the debug_value using constructs that assume that the value is live for
+the entire function (e.x.: llvm.dbg.declare). NOTE: This is implicitly set to
+true if the alloc_stack's type is noncopyable. This is just done to make SIL
+less verbose.
 
 ::
 

include/swift/SIL/DebugUtils.h

@@ -492,10 +492,7 @@ struct DebugVarCarryingInst : VarDeclCarryingInst {
   ///
   /// For a debug_value, we just return the actual operand, otherwise we return
   /// the pointer address.
-  ///
-  /// If we have an alloc_box, we return a new project_box. This is the only
-  /// case where a SILBuilder is required.
-  SILValue getOperandForDebugValueClone(SILBuilder *builder = nullptr) const {
+  SILValue getOperandForDebugValueClone() const {
     switch (getKind()) {
     case Kind::Invalid:
       llvm_unreachable("Invalid?!");
@@ -504,10 +501,7 @@ struct DebugVarCarryingInst : VarDeclCarryingInst {
     case Kind::AllocStack:
       return cast<AllocStackInst>(**this);
     case Kind::AllocBox:
-      assert(builder);
-      return builder->createProjectBox(
-          RegularLocation::getAutoGeneratedLocation(),
-          cast<AllocBoxInst>(**this), 0);
+      return cast<AllocBoxInst>(**this);
     }
   }
 

lib/SIL/IR/SILInstructions.cpp

@@ -241,7 +241,7 @@ AllocStackInst::AllocStackInst(SILDebugLocation Loc, SILType elementType,
   sharedUInt8().AllocStackInst.dynamicLifetime = hasDynamicLifetime;
   sharedUInt8().AllocStackInst.lexical = isLexical;
   sharedUInt8().AllocStackInst.usesMoveableValueDebugInfo =
-      usesMoveableValueDebugInfo;
+      usesMoveableValueDebugInfo || elementType.isMoveOnly();
   sharedUInt32().AllocStackInst.numOperands = TypeDependentOperands.size();
 
   // VarInfo must be initialized after
@@ -382,6 +382,11 @@ AllocBoxInst::AllocBoxInst(SILDebugLocation Loc, CanSILBoxType BoxType,
       VarInfo(Var, getTrailingObjects<char>()) {
   sharedUInt8().AllocBoxInst.dynamicLifetime = hasDynamicLifetime;
   sharedUInt8().AllocBoxInst.reflection = reflection;
+
+  // If we have a noncopyable type, always set uses mvoeable value debug info.
+  usesMoveableValueDebugInfo |=
+      BoxType->getLayout()->getFields()[0].getObjectType().isMoveOnly();
+
   sharedUInt8().AllocBoxInst.usesMoveableValueDebugInfo =
       usesMoveableValueDebugInfo;
 }
@@ -409,7 +414,7 @@ SILType AllocBoxInst::getAddressType() const {
 
 DebugValueInst::DebugValueInst(SILDebugLocation DebugLoc, SILValue Operand,
                                SILDebugVariable Var, bool poisonRefs,
-                               bool wasMoved, bool trace)
+                               bool usesMoveableValueDebugInfo, bool trace)
     : UnaryInstructionBase(DebugLoc, Operand),
       SILDebugVariableSupplement(Var.DIExpr.getNumElements(),
                                  Var.Type.has_value(), Var.Loc.has_value(),
@@ -421,7 +426,7 @@ DebugValueInst::DebugValueInst(SILDebugLocation DebugLoc, SILValue Operand,
   if (auto *VD = DebugLoc.getLocation().getAsASTNode<VarDecl>())
     VarInfo.setImplicit(VD->isImplicit() || VarInfo.isImplicit());
   setPoisonRefs(poisonRefs);
-  if (wasMoved)
+  if (usesMoveableValueDebugInfo || Operand->getType().isMoveOnly())
     setUsesMoveableValueDebugInfo();
   setTrace(trace);
 }

lib/SIL/IR/SILPrinter.cpp

@@ -1393,7 +1393,7 @@ class SILPrinter : public SILInstructionVisitor<SILPrinter> {
       *this << "[dynamic_lifetime] ";
     if (AVI->isLexical())
       *this << "[lexical] ";
-    if (AVI->getUsesMoveableValueDebugInfo())
+    if (AVI->getUsesMoveableValueDebugInfo() && !AVI->getType().isMoveOnly())
       *this << "[moveable_value_debuginfo] ";
     *this << AVI->getElementType();
     printDebugVar(AVI->getVarInfo(),
@@ -1435,7 +1435,8 @@ class SILPrinter : public SILInstructionVisitor<SILPrinter> {
       *this << "[reflection] ";
     }
 
-    if (ABI->getUsesMoveableValueDebugInfo()) {
+    if (ABI->getUsesMoveableValueDebugInfo() &&
+        !ABI->getAddressType().isMoveOnly()) {
       *this << "[moveable_value_debuginfo] ";
     }
 
@@ -1769,7 +1770,8 @@ class SILPrinter : public SILInstructionVisitor<SILPrinter> {
   void visitDebugValueInst(DebugValueInst *DVI) {
     if (DVI->poisonRefs())
       *this << "[poison] ";
-    if (DVI->getUsesMoveableValueDebugInfo())
+    if (DVI->getUsesMoveableValueDebugInfo() &&
+        !DVI->getOperand()->getType().isMoveOnly())
       *this << "[moveable_value_debuginfo] ";
     if (DVI->hasTrace())
       *this << "[trace] ";

lib/SIL/Parser/ParseSIL.cpp

@@ -2858,6 +2858,10 @@ bool SILParser::parseSpecificSILInstruction(SILBuilder &B,
       return true;
     if (parseSILDebugLocation(InstLoc, B))
       return true;
+
+    if (Ty.isMoveOnly())
+      usesMoveableValueDebugInfo = true;
+
     ResultVal = B.createAllocBox(InstLoc, Ty.castTo<SILBoxType>(), VarInfo,
                                  hasDynamicLifetime, hasReflection,
                                  usesMoveableValueDebugInfo);
@@ -3612,6 +3616,10 @@ bool SILParser::parseSpecificSILInstruction(SILBuilder &B,
       return true;
     if (Val->getType().isAddress())
       assert(!poisonRefs && "debug_value w/ address value does not support poison");
+
+    if (Val->getType().isMoveOnly())
+      usesMoveableValueDebugInfo = true;
+
     ResultVal = B.createDebugValue(InstLoc, Val, VarInfo, poisonRefs,
                                    usesMoveableValueDebugInfo, hasTrace);
     break;
@@ -4715,6 +4723,10 @@ bool SILParser::parseSpecificSILInstruction(SILBuilder &B,
     SILDebugVariable VarInfo;
     if (parseSILDebugVar(VarInfo) || parseSILDebugLocation(InstLoc, B))
       return true;
+
+    if (Ty.isMoveOnly())
+      usesMoveableValueDebugInfo = true;
+
     // It doesn't make sense to attach a debug var info if the name is empty
     if (VarInfo.Name.size())
       ResultVal = B.createAllocStack(InstLoc, Ty, VarInfo, hasDynamicLifetime,