[sil] Rename [moved] flag on debug_value/alloc_stack to moveable_value_debuginfo.

This is in preparation for wiring up debug info support for noncopyable
values. Originally this flag name made sense since it was set when we performed
consume operator checking. Now I am going to use it for noncopyable types as
well. I think the new name uses_moveable_value_debuginfo actually describes what
the flag is supposed to do, tell IRGen that the value may be moved since it
needs to use moveable value debug info emission.

Author: gottesmm

SwiftCompilerSources/Sources/SIL/Builder.swift

@@ -84,9 +84,10 @@ public struct Builder {
   }
 
   public func createAllocStack(_ type: Type, hasDynamicLifetime: Bool = false,
-                               isLexical: Bool = false, wasMoved: Bool = false) -> AllocStackInst {
+                               isLexical: Bool = false,
+                               usesMoveableValueDebugInfo: Bool = false) -> AllocStackInst {
     let dr = SILBuilder_createAllocStack(bridged, type.bridged, hasDynamicLifetime ? 1 : 0,
-                                         isLexical ? 1 : 0, wasMoved ? 1 : 0)
+                                         isLexical ? 1 : 0, usesMoveableValueDebugInfo ? 1 : 0)
     return notifyNew(dr.getAs(AllocStackInst.self))
   }
 

docs/SIL.rst

@@ -3745,7 +3745,10 @@ alloc_stack
 ```````````
 ::
 
-  sil-instruction ::= 'alloc_stack' '[dynamic_lifetime]'? '[lexical]'? '[moved]'? sil-type (',' debug-var-attr)*
+  sil-instruction ::= 'alloc_stack' alloc-stack-option* sil-type (',' debug-var-attr)*
+  alloc-stack-option ::= '[dynamic_lifetime]'
+  alloc-stack-option ::= '[lexical]'
+  alloc-stack-option ::= '[moveable_value_debuginfo]'
 
   %1 = alloc_stack $T
   // %1 has type $*T
@@ -3767,11 +3770,10 @@ 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 ``moved`` attribute specifies that at the source level, the
-variable associated with this alloc_stack was moved and furthermore that at the
-SIL level it passed move operator checking. This means that one 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.
 
 The memory is not retainable. To allocate a retainable box for a value
 type, use ``alloc_box``.
@@ -4155,7 +4157,7 @@ debug_value
 
 ::
 
-  sil-instruction ::= debug_value '[poison]'? '[moved]'? '[trace]'? sil-operand (',' debug-var-attr)* advanced-debug-var-attr* (',' 'expr' debug-info-expr)?
+  sil-instruction ::= debug_value '[poison]'? '[moveable_value_debuginfo]'? '[trace]'? sil-operand (',' debug-var-attr)* advanced-debug-var-attr* (',' 'expr' debug-info-expr)?
 
   debug_value %1 : $Int
 
@@ -4164,7 +4166,7 @@ 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 '[moved]' flag is set, then one knows that the debug_value's operand is
+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).

include/swift/SIL/DebugUtils.h

@@ -460,10 +460,10 @@ struct DebugVarCarryingInst : VarDeclCarryingInst {
     case Kind::Invalid:
       llvm_unreachable("Invalid?!");
     case Kind::DebugValue:
-      cast<DebugValueInst>(**this)->markAsMoved();
+      cast<DebugValueInst>(**this)->setUsesMoveableValueDebugInfo();
       break;
     case Kind::AllocStack:
-      cast<AllocStackInst>(**this)->markAsMoved();
+      cast<AllocStackInst>(**this)->markUsesMoveableValueDebugInfo();
       break;
     case Kind::AllocBox:
       llvm_unreachable("Not implemented");
@@ -476,9 +476,9 @@ struct DebugVarCarryingInst : VarDeclCarryingInst {
     case Kind::Invalid:
       llvm_unreachable("Invalid?!");
     case Kind::DebugValue:
-      return cast<DebugValueInst>(**this)->getWasMoved();
+      return cast<DebugValueInst>(**this)->getUsesMoveableValueDebugInfo();
     case Kind::AllocStack:
-      return cast<AllocStackInst>(**this)->getWasMoved();
+      return cast<AllocStackInst>(**this)->getUsesMoveableValueDebugInfo();
     case Kind::AllocBox:
       // We do not support moving alloc box today, so we always return false.
       return false;

include/swift/SIL/SILCloner.h

@@ -893,7 +893,8 @@ SILCloner<ImplClass>::visitAllocStackInst(AllocStackInst *Inst) {
   }
   auto *NewInst = getBuilder().createAllocStack(
       Loc, getOpType(Inst->getElementType()), VarInfo,
-      Inst->hasDynamicLifetime(), Inst->isLexical(), Inst->getWasMoved());
+      Inst->hasDynamicLifetime(), Inst->isLexical(),
+      Inst->getUsesMoveableValueDebugInfo());
   remapDebugVarInfo(DebugVarCarryingInst(NewInst));
   recordClonedInstruction(Inst, NewInst);
 }
@@ -1380,7 +1381,8 @@ SILCloner<ImplClass>::visitDebugValueInst(DebugValueInst *Inst) {
   getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));
   auto *NewInst = getBuilder().createDebugValue(
       Inst->getLoc(), getOpValue(Inst->getOperand()), VarInfo,
-      Inst->poisonRefs(), Inst->getWasMoved(), Inst->hasTrace());
+      Inst->poisonRefs(), Inst->getUsesMoveableValueDebugInfo(),
+      Inst->hasTrace());
   remapDebugVarInfo(DebugVarCarryingInst(NewInst));
   recordClonedInstruction(Inst, NewInst);
 }

include/swift/SIL/SILInstruction.h

@@ -2094,12 +2094,12 @@ class AllocStackInst final
   AllocStackInst(SILDebugLocation Loc, SILType elementType,
                  ArrayRef<SILValue> TypeDependentOperands, SILFunction &F,
                  Optional<SILDebugVariable> Var, bool hasDynamicLifetime,
-                 bool isLexical, bool wasMoved);
+                 bool isLexical, bool usesMoveableValueDebugInfo);
 
   static AllocStackInst *create(SILDebugLocation Loc, SILType elementType,
                                 SILFunction &F, Optional<SILDebugVariable> Var,
                                 bool hasDynamicLifetime, bool isLexical,
-                                bool wasMoved);
+                                bool usesMoveableValueDebugInfo);
 
   SIL_DEBUG_VAR_SUPPLEMENT_TRAILING_OBJS_IMPL()
 
@@ -2116,11 +2116,15 @@ class AllocStackInst final
     }
   }
 
-  void markAsMoved() { sharedUInt8().AllocStackInst.wasMoved = true; }
+  void markUsesMoveableValueDebugInfo() {
+    sharedUInt8().AllocStackInst.usesMoveableValueDebugInfo = true;
+  }
 
   /// Set to true if this alloc_stack's memory location was passed to _move at
   /// any point of the program.
-  bool getWasMoved() const { return sharedUInt8().AllocStackInst.wasMoved; }
+  bool getUsesMoveableValueDebugInfo() const {
+    return sharedUInt8().AllocStackInst.usesMoveableValueDebugInfo;
+  }
 
   /// Set to true that this alloc_stack contains a value whose lifetime can not
   /// be ascertained from uses.
@@ -5012,14 +5016,17 @@ class DebugValueInst final
   size_t numTrailingObjects(OverloadToken<char>) const { return 1; }
 
 public:
-  void markAsMoved() { sharedUInt8().DebugValueInst.operandWasMoved = true; }
+  /// Sets a bool that states this debug_value is supposed to use the
+  void setUsesMoveableValueDebugInfo() {
+    sharedUInt8().DebugValueInst.usesMoveableValueDebugInfo = true;
+  }
 
   /// True if this debug_value is on an SSA value that was moved.
   ///
   /// IRGen uses this information to determine if we should use llvm.dbg.addr or
   /// llvm.dbg.declare.
-  bool getWasMoved() const {
-    return sharedUInt8().DebugValueInst.operandWasMoved;
+  bool getUsesMoveableValueDebugInfo() const {
+    return sharedUInt8().DebugValueInst.usesMoveableValueDebugInfo;
   }
 
   /// Return the underlying variable declaration that this denotes,

include/swift/SIL/SILNode.h

@@ -174,6 +174,7 @@ class alignas(8) SILNode :
 #define SHARED_TEMPLATE4_FIELD(T1, T2, T3, T4, I, ...) \
   class { template <T1, T2, T3, T4> friend class I; __VA_ARGS__; } I;
 
+  // clang-format off
   union SharedUInt8Fields {
     uint8_t opaque;
 
@@ -203,15 +204,15 @@ class alignas(8) SILNode :
     SHARED_FIELD(BeginCOWMutationInst, bool native);
 
     SHARED_FIELD(DebugValueInst, uint8_t
-      poisonRefs : 1,
-      operandWasMoved : 1,
-      trace : 1);
+                 poisonRefs : 1,
+                 usesMoveableValueDebugInfo : 1,
+                 trace : 1);
 
     SHARED_FIELD(AllocStackInst, uint8_t
-      dynamicLifetime : 1,
-      lexical : 1,
-      wasMoved : 1,
-      hasInvalidatedVarInfo : 1);
+                 dynamicLifetime : 1,
+                 lexical : 1,
+                 usesMoveableValueDebugInfo : 1,
+                 hasInvalidatedVarInfo : 1);
 
     SHARED_FIELD(AllocRefInstBase, uint8_t
       objC : 1,
@@ -243,10 +244,12 @@ class alignas(8) SILNode :
 
   // Do not use `_sharedUInt8_private` outside of SILNode.
   } _sharedUInt8_private;
+  // clang-format on
 
   static_assert(sizeof(SharedUInt8Fields) == sizeof(uint8_t),
     "A SILNode's shared uint8 field is too large");
 
+  // clang-format off
   union SharedUInt32Fields {
     uint32_t opaque;
 
@@ -272,6 +275,7 @@ class alignas(8) SILNode :
 
     // Do not use `_sharedUInt32_private` outside of SILNode.
   } _sharedUInt32_private;
+  // clang-format on
 
   static_assert(sizeof(SharedUInt32Fields) == sizeof(uint32_t),
     "A SILNode's shared uint32 field is too large");

lib/IRGen/AllocStackHoisting.cpp

@@ -113,8 +113,9 @@ class Partition {
   /// statistics to make sure that we haven't hurt debuggability by making the
   /// change.
   bool hasMovedElt() const {
-    return llvm::any_of(Elts,
-                        [](AllocStackInst *asi) { return asi->getWasMoved(); });
+    return llvm::any_of(Elts, [](AllocStackInst *asi) {
+      return asi->getUsesMoveableValueDebugInfo();
+    });
   }
 };
 } // end anonymous namespace
@@ -155,10 +156,10 @@ void moveAllocStackToBeginningOfBlock(
     if (auto varInfo = AS->getVarInfo()) {
       SILBuilderWithScope Builder(AS);
       auto *DVI = Builder.createDebugValue(AS->getLoc(), AS, *varInfo);
-      DVI->markAsMoved();
+      DVI->setUsesMoveableValueDebugInfo();
       DebugValueToBreakBlocksAt.push_back(DVI);
       AS->invalidateVarInfo();
-      AS->markAsMoved();
+      AS->markUsesMoveableValueDebugInfo();
     }
   }
   AS->moveFront(BB);
@@ -197,7 +198,7 @@ void Partition::assignStackLocation(
         SILBuilderWithScope Builder(AllocStack);
         auto *DVI = Builder.createDebugValue(AllocStack->getLoc(), AssignedLoc,
                                              *VarInfo);
-        DVI->markAsMoved();
+        DVI->setUsesMoveableValueDebugInfo();
         DebugValueToBreakBlocksAt.push_back(DVI);
       }
     }

lib/IRGen/IRGenSIL.cpp

@@ -5087,7 +5087,7 @@ void IRGenSILFunction::visitDebugValueInst(DebugValueInst *i) {
 
     // If we were not moved return early. If this SILUndef was moved, then we
     // need to let it through so we can ensure the debug info invalidated.
-    if (!i->getWasMoved())
+    if (!i->getUsesMoveableValueDebugInfo())
       return;
   }
   bool IsInCoro = InCoroContext(*CurSILFn, *i);
@@ -5138,18 +5138,18 @@ void IRGenSILFunction::visitDebugValueInst(DebugValueInst *i) {
   if (IsAddrVal)
     Copy.emplace_back(emitShadowCopyIfNeeded(
         getLoweredAddress(SILVal).getAddress(), i->getDebugScope(), *VarInfo,
-        IsAnonymous, i->getWasMoved()));
+        IsAnonymous, i->getUsesMoveableValueDebugInfo()));
   else
     emitShadowCopyIfNeeded(SILVal, i->getDebugScope(), *VarInfo, IsAnonymous,
-                           i->getWasMoved(), Copy);
+                           i->getUsesMoveableValueDebugInfo(), Copy);
 
   bindArchetypes(DbgTy.getType());
   if (!IGM.DebugInfo)
     return;
 
-  emitDebugVariableDeclaration(Copy, DbgTy, SILTy, i->getDebugScope(),
-                               i->getLoc(), *VarInfo, Indirection,
-                               AddrDbgInstrKind(i->getWasMoved()));
+  emitDebugVariableDeclaration(
+      Copy, DbgTy, SILTy, i->getDebugScope(), i->getLoc(), *VarInfo,
+      Indirection, AddrDbgInstrKind(i->getUsesMoveableValueDebugInfo()));
 }
 
 void IRGenSILFunction::visitDebugStepInst(DebugStepInst *i) {
@@ -5479,7 +5479,7 @@ void IRGenSILFunction::emitDebugInfoForAllocStack(AllocStackInst *i,
       if (!Alloca->isStaticAlloca()) {
         // Store the address of the dynamic alloca on the stack.
         addr = emitShadowCopy(addr, DS, *VarInfo, IGM.getPointerAlignment(),
-                              /*init*/ true, i->getWasMoved())
+                              /*init*/ true, i->getUsesMoveableValueDebugInfo())
                    .getAddress();
         Indirection =
             InCoroContext(*CurSILFn, *i) ? CoroIndirectValue : IndirectValue;
@@ -5518,9 +5518,9 @@ void IRGenSILFunction::emitDebugInfoForAllocStack(AllocStackInst *i,
 
   bindArchetypes(DbgTy.getType());
   if (IGM.DebugInfo) {
-    emitDebugVariableDeclaration(addr, DbgTy, SILTy, DS, i->getLoc(), *VarInfo,
-                                 Indirection,
-                                 AddrDbgInstrKind(i->getWasMoved()));
+    emitDebugVariableDeclaration(
+        addr, DbgTy, SILTy, DS, i->getLoc(), *VarInfo, Indirection,
+        AddrDbgInstrKind(i->getUsesMoveableValueDebugInfo()));
   }
 }
 

lib/SIL/IR/SILInstructions.cpp

@@ -229,7 +229,7 @@ AllocStackInst::AllocStackInst(SILDebugLocation Loc, SILType elementType,
                                ArrayRef<SILValue> TypeDependentOperands,
                                SILFunction &F, Optional<SILDebugVariable> Var,
                                bool hasDynamicLifetime, bool isLexical,
-                               bool wasMoved)
+                               bool usesMoveableValueDebugInfo)
     : InstructionBase(Loc, elementType.getAddressType()),
       SILDebugVariableSupplement(Var ? Var->DIExpr.getNumElements() : 0,
                                  Var ? Var->Type.has_value() : false,
@@ -240,20 +240,22 @@ AllocStackInst::AllocStackInst(SILDebugLocation Loc, SILType elementType,
       VarInfo(0) {
   sharedUInt8().AllocStackInst.dynamicLifetime = hasDynamicLifetime;
   sharedUInt8().AllocStackInst.lexical = isLexical;
-  sharedUInt8().AllocStackInst.wasMoved = wasMoved;
+  sharedUInt8().AllocStackInst.usesMoveableValueDebugInfo =
+      usesMoveableValueDebugInfo;
   sharedUInt32().AllocStackInst.numOperands = TypeDependentOperands.size();
 
-  // VarInfo must be initialized after `sharedUInt32().AllocStackInst.numOperands`!
-  // Otherwise the trailing object addresses are wrong.
-  VarInfo = TailAllocatedDebugVariable(Var,
-               getTrailingObjects<char>(),
-               getTrailingObjects<SILType>(),
-               getTrailingObjects<SILLocation>(),
-               getTrailingObjects<const SILDebugScope *>(),
-               getTrailingObjects<SILDIExprElement>());
+  // VarInfo must be initialized after
+  // `sharedUInt32().AllocStackInst.numOperands`! Otherwise the trailing object
+  // addresses are wrong.
+  VarInfo = TailAllocatedDebugVariable(
+      Var, getTrailingObjects<char>(), getTrailingObjects<SILType>(),
+      getTrailingObjects<SILLocation>(),
+      getTrailingObjects<const SILDebugScope *>(),
+      getTrailingObjects<SILDIExprElement>());
 
   assert(sharedUInt32().AllocStackInst.numOperands ==
-         TypeDependentOperands.size() && "Truncation");
+             TypeDependentOperands.size() &&
+         "Truncation");
   auto *VD = Loc.getLocation().getAsASTNode<VarDecl>();
   if (Var && VD) {
     VarInfo.setImplicit(VD->isImplicit() || VarInfo.isImplicit());
@@ -417,7 +419,7 @@ DebugValueInst::DebugValueInst(SILDebugLocation DebugLoc, SILValue Operand,
     VarInfo.setImplicit(VD->isImplicit() || VarInfo.isImplicit());
   setPoisonRefs(poisonRefs);
   if (wasMoved)
-    markAsMoved();
+    setUsesMoveableValueDebugInfo();
   setTrace(trace);
 }
 

lib/SIL/IR/SILPrinter.cpp

@@ -1393,8 +1393,8 @@ class SILPrinter : public SILInstructionVisitor<SILPrinter> {
       *this << "[dynamic_lifetime] ";
     if (AVI->isLexical())
       *this << "[lexical] ";
-    if (AVI->getWasMoved())
-      *this << "[moved] ";
+    if (AVI->getUsesMoveableValueDebugInfo())
+      *this << "[moveable_value_debuginfo] ";
     *this << AVI->getElementType();
     printDebugVar(AVI->getVarInfo(),
                   &AVI->getModule().getASTContext().SourceMgr);
@@ -1764,8 +1764,8 @@ class SILPrinter : public SILInstructionVisitor<SILPrinter> {
   void visitDebugValueInst(DebugValueInst *DVI) {
     if (DVI->poisonRefs())
       *this << "[poison] ";
-    if (DVI->getWasMoved())
-      *this << "[moved] ";
+    if (DVI->getUsesMoveableValueDebugInfo())
+      *this << "[moveable_value_debuginfo] ";
     if (DVI->hasTrace())
       *this << "[trace] ";
     *this << getIDAndType(DVI->getOperand());