Textualize assign init kind

Rename [assign] to [reassign]

fix some tests

AssignOwnershipQualifier

formatting

moar formatting

Author: Azoy

include/swift/SIL/SILBuilder.h

@@ -812,9 +812,11 @@ class SILBuilder {
         getSILDebugLocation(loc), buffer, enforcement, aborted, fromBuiltin));
   }
 
-  AssignInst *createAssign(SILLocation Loc, SILValue Src, SILValue DestAddr) {
+  AssignInst *createAssign(SILLocation Loc, SILValue Src, SILValue DestAddr,
+                           AssignOwnershipQualifier Qualifier) {
     return insert(new (getModule())
-                      AssignInst(getSILDebugLocation(Loc), Src, DestAddr));
+                      AssignInst(getSILDebugLocation(Loc), Src, DestAddr,
+                                 Qualifier));
   }
 
   StoreBorrowInst *createStoreBorrow(SILLocation Loc, SILValue Src,

include/swift/SIL/SILCloner.h

@@ -1200,7 +1200,8 @@ void SILCloner<ImplClass>::visitAssignInst(AssignInst *Inst) {
   recordClonedInstruction(
       Inst, getBuilder().createAssign(getOpLocation(Inst->getLoc()),
                                       getOpValue(Inst->getSrc()),
-                                      getOpValue(Inst->getDest())));
+                                      getOpValue(Inst->getDest()),
+                                      Inst->getOwnershipQualifier()));
 }
 
 template<typename ImplClass>

include/swift/SIL/SILInstruction.h

@@ -3603,21 +3603,24 @@ class EndUnpairedAccessInst
   }
 };
 
-enum class PartialInitializationKind {
+// *NOTE* When serializing, we can only represent up to 4 values here. If more
+// qualifiers are added, SIL serialization must be updated.
+enum class AssignOwnershipQualifier {
   /// Unknown initialization method
   Unknown,
 
   /// The box contains a fully-initialized value.
-  IsNotInitialization,
+  Reassign,
 
   /// The box contains a class instance that we own, but the instance has
   /// not been initialized and should be freed with a special SIL
   /// instruction made for this purpose.
-  IsReinitialization,
+  Reinit,
 
   /// The box contains an undefined value that should be ignored.
-  IsInitialization,
+  Init,
 };
+static_assert(2 == SILNode::NumAssignOwnershipQualifierBits, "Size mismatch");
 
 /// AssignInst - Represents an abstract assignment to a memory location, which
 /// may either be an initialization or a store sequence.  This is only valid in
@@ -3628,9 +3631,10 @@ class AssignInst
   friend SILBuilder;
 
   FixedOperandList<2> Operands;
-  PartialInitializationKind InitKind;
 
-  AssignInst(SILDebugLocation DebugLoc, SILValue Src, SILValue Dest);
+  AssignInst(SILDebugLocation DebugLoc, SILValue Src, SILValue Dest,
+             AssignOwnershipQualifier Qualifier =
+                AssignOwnershipQualifier::Unknown);
 
 public:
   enum {
@@ -3646,8 +3650,13 @@ class AssignInst
   ArrayRef<Operand> getAllOperands() const { return Operands.asArray(); }
   MutableArrayRef<Operand> getAllOperands() { return Operands.asArray(); }
 
-  PartialInitializationKind getInitKind() const { return InitKind; }
-  void setInitKind(PartialInitializationKind initKind) { InitKind = initKind; }
+  AssignOwnershipQualifier getOwnershipQualifier() const {
+    return AssignOwnershipQualifier(
+      SILInstruction::Bits.AssignInst.OwnershipQualifier);
+  }
+  void setOwnershipQualifier(AssignOwnershipQualifier qualifier) {
+    SILInstruction::Bits.AssignInst.OwnershipQualifier = unsigned(qualifier);
+  }
 };
 
 /// Indicates that a memory location is uninitialized at this point and needs to

include/swift/SIL/SILNode.h

@@ -96,6 +96,7 @@ class alignas(8) SILNode {
   enum { NumVOKindBits = 3 };
   enum { NumStoreOwnershipQualifierBits = 2 };
   enum { NumLoadOwnershipQualifierBits = 2 };
+  enum { NumAssignOwnershipQualifierBits = 2 };
   enum { NumSILAccessKindBits = 2 };
   enum { NumSILAccessEnforcementBits = 2 };
 
@@ -280,6 +281,10 @@ class alignas(8) SILNode {
                         NumLoadOwnershipQualifierBits,
     OwnershipQualifier : NumLoadOwnershipQualifierBits
   );
+  SWIFT_INLINE_BITFIELD(AssignInst, NonValueInstruction,
+                        NumAssignOwnershipQualifierBits,
+    OwnershipQualifier : NumAssignOwnershipQualifierBits
+  );
 
   SWIFT_INLINE_BITFIELD(UncheckedOwnershipConversionInst,SingleValueInstruction,
                         NumVOKindBits,

include/swift/Serialization/ModuleFormat.h

@@ -52,7 +52,7 @@ const uint16_t SWIFTMODULE_VERSION_MAJOR = 0;
 /// describe what change you made. The content of this comment isn't important;
 /// it just ensures a conflict if two people change the module format.
 /// Don't worry about adhering to the 80-column limit for this line.
-const uint16_t SWIFTMODULE_VERSION_MINOR = 472; // Last change: partial_apply [stack]
+const uint16_t SWIFTMODULE_VERSION_MINOR = 473; // Last change: assign ownership qualifier
 
 using DeclIDField = BCFixed<31>;
 

lib/ParseSIL/ParseSIL.cpp

@@ -1956,6 +1956,32 @@ static bool parseStoreOwnershipQualifier(StoreOwnershipQualifier &Result,
   return false;
 }
 
+static bool parseAssignOwnershipQualifier(AssignOwnershipQualifier &Result,
+                                          SILParser &P) {
+  StringRef Str;
+  // If we do not parse '[' ... ']', we have unknown. Set value and return.
+  if (!parseSILOptional(Str, P)) {
+    Result = AssignOwnershipQualifier::Unknown;
+    return false;
+  }
+
+  // Then try to parse one of our other initialization kinds. We do not support
+  // parsing unknown here so we use that as our fail value.
+  auto Tmp = llvm::StringSwitch<AssignOwnershipQualifier>(Str)
+                 .Case("reassign", AssignOwnershipQualifier::Reassign)
+                 .Case("reinit", AssignOwnershipQualifier::Reinit)
+                 .Case("init", AssignOwnershipQualifier::Init)
+                 .Default(AssignOwnershipQualifier::Unknown);
+
+  // Thus return true (following the conventions in this file) if we fail.
+  if (Tmp == AssignOwnershipQualifier::Unknown)
+    return true;
+
+  // Otherwise, assign Result and return false.
+  Result = Tmp;
+  return false;
+}
+
 bool SILParser::parseSILDeclRef(SILDeclRef &Member, bool FnTypeRequired) {
   SourceLoc TyLoc;
   SmallVector<ValueDecl *, 4> values;
@@ -3448,18 +3474,25 @@ bool SILParser::parseSILInstruction(SILBuilder &B) {
     break;
   }
 
+  case SILInstructionKind::AssignInst:
   case SILInstructionKind::StoreInst: {
     UnresolvedValueName From;
     SourceLoc ToLoc, AddrLoc;
     Identifier ToToken;
     SILValue AddrVal;
-    StoreOwnershipQualifier Qualifier;
+    StoreOwnershipQualifier StoreQualifier;
+    AssignOwnershipQualifier AssignQualifier;
+    bool IsStore = Opcode == SILInstructionKind::StoreInst;
+    bool IsAssign = Opcode == SILInstructionKind::AssignInst;
     if (parseValueName(From) ||
         parseSILIdentifier(ToToken, ToLoc, diag::expected_tok_in_sil_instr,
                            "to"))
       return true;
 
-    if (parseStoreOwnershipQualifier(Qualifier, *this))
+    if (IsStore && parseStoreOwnershipQualifier(StoreQualifier, *this))
+      return true;
+
+    if (IsAssign && parseAssignOwnershipQualifier(AssignQualifier, *this))
       return true;
 
     if (parseTypedValueRef(AddrVal, AddrLoc, B) ||
@@ -3479,8 +3512,18 @@ bool SILParser::parseSILInstruction(SILBuilder &B) {
 
     SILType ValType = AddrVal->getType().getObjectType();
 
-    ResultVal = B.createStore(InstLoc, getLocalValue(From, ValType, InstLoc, B),
-                              AddrVal, Qualifier);
+    if (IsStore) {
+      ResultVal = B.createStore(InstLoc,
+                                getLocalValue(From, ValType, InstLoc, B),
+                                AddrVal, StoreQualifier);
+    } else {
+      assert(IsAssign);
+
+      ResultVal = B.createAssign(InstLoc,
+                                getLocalValue(From, ValType, InstLoc, B),
+                                AddrVal, AssignQualifier);
+    }
+
     break;
   }
 
@@ -3619,8 +3662,7 @@ bool SILParser::parseSILInstruction(SILBuilder &B) {
 #define NEVER_OR_SOMETIMES_LOADABLE_CHECKED_REF_STORAGE(Name, ...) \
   case SILInstructionKind::Store##Name##Inst:
 #include "swift/AST/ReferenceStorage.def"
-  case SILInstructionKind::StoreBorrowInst:
-  case SILInstructionKind::AssignInst: {
+  case SILInstructionKind::StoreBorrowInst: {
     UnresolvedValueName from;
     bool isRefStorage = false;
 #define NEVER_OR_SOMETIMES_LOADABLE_CHECKED_REF_STORAGE(Name, ...) \
@@ -3673,12 +3715,6 @@ bool SILParser::parseSILInstruction(SILBuilder &B) {
     }
 #include "swift/AST/ReferenceStorage.def"
 
-    SILType ValType = addrVal->getType().getObjectType();
-
-    assert(Opcode == SILInstructionKind::AssignInst);
-    ResultVal = B.createAssign(InstLoc,
-                               getLocalValue(from, ValType, InstLoc, B),
-                               addrVal);
     break;
   }
   case SILInstructionKind::AllocStackInst:

lib/SIL/SILInstructions.cpp

@@ -812,9 +812,11 @@ StringRef swift::getSILAccessEnforcementName(SILAccessEnforcement enforcement) {
   llvm_unreachable("bad access enforcement");
 }
 
-AssignInst::AssignInst(SILDebugLocation Loc, SILValue Src, SILValue Dest)
-    : InstructionBase(Loc), Operands(this, Src, Dest),
-      InitKind(PartialInitializationKind::Unknown) {}
+AssignInst::AssignInst(SILDebugLocation Loc, SILValue Src, SILValue Dest,
+                       AssignOwnershipQualifier Qualifier)
+    : InstructionBase(Loc), Operands(this, Src, Dest) {
+  SILInstruction::Bits.AssignInst.OwnershipQualifier = unsigned(Qualifier);
+}
 
 MarkFunctionEscapeInst *
 MarkFunctionEscapeInst::create(SILDebugLocation Loc,

lib/SIL/SILPrinter.cpp

@@ -1272,6 +1272,22 @@ class SILPrinter : public SILInstructionVisitor<SILPrinter> {
     }
   }
 
+  void printAssignOwnershipQualifier(AssignOwnershipQualifier Qualifier) {
+    switch (Qualifier) {
+    case AssignOwnershipQualifier::Unknown:
+      return;
+    case AssignOwnershipQualifier::Init:
+      *this << "[init] ";
+      return;
+    case AssignOwnershipQualifier::Reassign:
+      *this << "[reassign] ";
+      return;
+    case AssignOwnershipQualifier::Reinit:
+      *this << "[reinit] ";
+      return;
+    }
+  }
+
   void visitStoreInst(StoreInst *SI) {
     *this << Ctx.getID(SI->getSrc()) << " to ";
     printStoreOwnershipQualifier(SI->getOwnershipQualifier());
@@ -1288,7 +1304,9 @@ class SILPrinter : public SILInstructionVisitor<SILPrinter> {
   }
 
   void visitAssignInst(AssignInst *AI) {
-    *this << Ctx.getID(AI->getSrc()) << " to " << getIDAndType(AI->getDest());
+    *this << Ctx.getID(AI->getSrc()) << " to ";
+    printAssignOwnershipQualifier(AI->getOwnershipQualifier());
+    *this << getIDAndType(AI->getDest());
   }
 
   void visitMarkUninitializedInst(MarkUninitializedInst *MU) {

lib/SILGen/SILGenLValue.cpp

@@ -3475,7 +3475,7 @@ static void emitUnloweredStoreOfCopy(SILGenBuilder &B, SILLocation loc,
   if (isInit) {
     B.emitStoreValueOperation(loc, value, addr, StoreOwnershipQualifier::Init);
   } else {
-    B.createAssign(loc, value, addr);
+    B.createAssign(loc, value, addr, AssignOwnershipQualifier::Unknown);
   }
 }
 

lib/SILOptimizer/Mandatory/DIMemoryUseCollector.cpp

@@ -1029,7 +1029,8 @@ void ElementUseCollector::collectUses(SILValue Pointer, unsigned BaseEltNo) {
         getScalarizedElements(AI->getOperand(0), ElementTmps, AI->getLoc(), B);
 
         for (unsigned i = 0, e = ElementAddrs.size(); i != e; ++i)
-          B.createAssign(AI->getLoc(), ElementTmps[i], ElementAddrs[i]);
+          B.createAssign(AI->getLoc(), ElementTmps[i], ElementAddrs[i],
+                         AssignOwnershipQualifier::Unknown);
         AI->eraseFromParent();
         continue;
       }