[sil] Add a moveable_value_debuginfo field to AllocBoxInst.

gottesmm · gottesmm · commit 8d12f893c291 · 2023-03-19T15:50:29.000-07:00
Just getting parsing/serialization to work. I haven't wired it up to anything.
diff --git a/docs/SIL.rst b/docs/SIL.rst
@@ -3867,7 +3867,8 @@ alloc_box
 `````````
 ::
 
-  sil-instruction ::= 'alloc_box' sil-type (',' debug-var-attr)*
+  sil-instruction ::= 'alloc_box' alloc-box-option* sil-type (',' debug-var-attr)*
+  alloc-box-option ::= moveable_value_debuginfo
 
   %1 = alloc_box $T
   //   %1 has type $@box T
@@ -3885,6 +3886,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.
+
 alloc_global
 ````````````
 
diff --git a/include/swift/SIL/DebugUtils.h b/include/swift/SIL/DebugUtils.h
@@ -37,6 +37,7 @@
 #define SWIFT_SIL_DEBUGUTILS_H
 
 #include "swift/SIL/SILBasicBlock.h"
+#include "swift/SIL/SILBuilder.h"
 #include "swift/SIL/SILGlobalVariable.h"
 #include "swift/SIL/SILInstruction.h"
 
@@ -466,7 +467,8 @@ struct DebugVarCarryingInst : VarDeclCarryingInst {
       cast<AllocStackInst>(**this)->markUsesMoveableValueDebugInfo();
       break;
     case Kind::AllocBox:
-      llvm_unreachable("Not implemented");
+      cast<AllocBoxInst>(**this)->setUsesMoveableValueDebugInfo();
+      break;
     }
   }
 
@@ -480,8 +482,7 @@ struct DebugVarCarryingInst : VarDeclCarryingInst {
     case Kind::AllocStack:
       return cast<AllocStackInst>(**this)->getUsesMoveableValueDebugInfo();
     case Kind::AllocBox:
-      // We do not support moving alloc box today, so we always return false.
-      return false;
+      return cast<AllocBoxInst>(**this)->getUsesMoveableValueDebugInfo();
     }
   }
 
@@ -491,7 +492,10 @@ struct DebugVarCarryingInst : VarDeclCarryingInst {
   ///
   /// For a debug_value, we just return the actual operand, otherwise we return
   /// the pointer address.
-  SILValue getOperandForDebugValueClone() const {
+  ///
+  /// 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 {
     switch (getKind()) {
     case Kind::Invalid:
       llvm_unreachable("Invalid?!");
@@ -500,7 +504,10 @@ struct DebugVarCarryingInst : VarDeclCarryingInst {
     case Kind::AllocStack:
       return cast<AllocStackInst>(**this);
     case Kind::AllocBox:
-      llvm_unreachable("Not implemented");
+      assert(builder);
+      return builder->createProjectBox(
+          RegularLocation::getAutoGeneratedLocation(),
+          cast<AllocBoxInst>(**this), 0);
     }
   }
 
diff --git a/include/swift/SIL/SILBuilder.h b/include/swift/SIL/SILBuilder.h
@@ -444,22 +444,26 @@ class SILBuilder {
   AllocBoxInst *createAllocBox(SILLocation loc, SILType fieldType,
                                Optional<SILDebugVariable> Var = None,
                                bool hasDynamicLifetime = false,
-                               bool reflection = false) {
+                               bool reflection = false,
+                               bool usesMoveableValueDebugInfo = false) {
     return createAllocBox(loc, SILBoxType::get(fieldType.getASTType()), Var,
-                          hasDynamicLifetime, reflection);
+                          hasDynamicLifetime, reflection,
+                          usesMoveableValueDebugInfo);
   }
 
   AllocBoxInst *createAllocBox(SILLocation Loc, CanSILBoxType BoxType,
                                Optional<SILDebugVariable> Var = None,
                                bool hasDynamicLifetime = false,
-                               bool reflection = false) {
+                               bool reflection = false,
+                               bool usesMoveableValueDebugInfo = false) {
     llvm::SmallString<4> Name;
     Loc.markAsPrologue();
     assert((!dyn_cast_or_null<VarDecl>(Loc.getAsASTNode<Decl>()) || Var) &&
            "location is a VarDecl, but SILDebugVariable is empty");
     return insert(AllocBoxInst::create(getSILDebugLocation(Loc), BoxType, *F,
                                        substituteAnonymousArgs(Name, Var, Loc),
-                                       hasDynamicLifetime, reflection));
+                                       hasDynamicLifetime, reflection,
+                                       usesMoveableValueDebugInfo));
   }
 
   AllocExistentialBoxInst *
diff --git a/include/swift/SIL/SILInstruction.h b/include/swift/SIL/SILInstruction.h
@@ -2461,13 +2461,13 @@ class AllocBoxInst final
   AllocBoxInst(SILDebugLocation DebugLoc, CanSILBoxType BoxType,
                ArrayRef<SILValue> TypeDependentOperands, SILFunction &F,
                Optional<SILDebugVariable> Var, bool hasDynamicLifetime,
-               bool reflection = false);
+               bool reflection = false,
+               bool usesMoveableValueDebugInfo = false);
 
   static AllocBoxInst *create(SILDebugLocation Loc, CanSILBoxType boxType,
-                              SILFunction &F,
-                              Optional<SILDebugVariable> Var,
-                              bool hasDynamicLifetime,
-                              bool reflection = false);
+                              SILFunction &F, Optional<SILDebugVariable> Var,
+                              bool hasDynamicLifetime, bool reflection = false,
+                              bool usesMoveableValueDebugInfo = false);
 
 public:
   CanSILBoxType getBoxType() const {
@@ -2495,6 +2495,14 @@ class AllocBoxInst final
   Optional<SILDebugVariable> getVarInfo() const {
     return VarInfo.get(getDecl(), getTrailingObjects<char>());
   };
+
+  void setUsesMoveableValueDebugInfo() {
+    sharedUInt8().AllocBoxInst.usesMoveableValueDebugInfo = true;
+  }
+
+  bool getUsesMoveableValueDebugInfo() const {
+    return sharedUInt8().AllocBoxInst.usesMoveableValueDebugInfo;
+  }
 };
 
 /// This represents the allocation of a heap box for an existential container.
diff --git a/include/swift/SIL/SILNode.h b/include/swift/SIL/SILNode.h
@@ -216,7 +216,8 @@ class alignas(8) SILNode :
 
     SHARED_FIELD(AllocBoxInst, uint8_t
                  dynamicLifetime : 1,
-                 reflection : 1);
+                 reflection : 1,
+                 usesMoveableValueDebugInfo : 1);
 
     SHARED_FIELD(AllocRefInstBase, uint8_t
       objC : 1,
diff --git a/lib/SIL/IR/SILBuilder.cpp b/lib/SIL/IR/SILBuilder.cpp
@@ -612,6 +612,7 @@ DebugValueInst *SILBuilder::createDebugValue(SILLocation Loc, SILValue src,
                                              bool operandWasMoved,
                                              bool trace) {
   llvm::SmallString<4> Name;
+
   // Debug location overrides cannot apply to debug value instructions.
   DebugLocOverrideRAII LocOverride{*this, None};
   return insert(DebugValueInst::create(
@@ -624,6 +625,7 @@ DebugValueInst *SILBuilder::createDebugValueAddr(SILLocation Loc, SILValue src,
                                                  SILDebugVariable Var,
                                                  bool wasMoved, bool trace) {
   llvm::SmallString<4> Name;
+
   // Debug location overrides cannot apply to debug addr instructions.
   DebugLocOverrideRAII LocOverride{*this, None};
   return insert(DebugValueInst::createAddr(
diff --git a/lib/SIL/IR/SILInstructions.cpp b/lib/SIL/IR/SILInstructions.cpp
@@ -375,27 +375,30 @@ bool AllocRefDynamicInst::isDynamicTypeDeinitAndSizeKnownEquivalentToBaseType()
 AllocBoxInst::AllocBoxInst(SILDebugLocation Loc, CanSILBoxType BoxType,
                            ArrayRef<SILValue> TypeDependentOperands,
                            SILFunction &F, Optional<SILDebugVariable> Var,
-                           bool hasDynamicLifetime, bool reflection)
+                           bool hasDynamicLifetime, bool reflection,
+                           bool usesMoveableValueDebugInfo)
     : NullaryInstructionWithTypeDependentOperandsBase(
           Loc, TypeDependentOperands, SILType::getPrimitiveObjectType(BoxType)),
       VarInfo(Var, getTrailingObjects<char>()) {
   sharedUInt8().AllocBoxInst.dynamicLifetime = hasDynamicLifetime;
   sharedUInt8().AllocBoxInst.reflection = reflection;
+  sharedUInt8().AllocBoxInst.usesMoveableValueDebugInfo =
+      usesMoveableValueDebugInfo;
 }
 
-AllocBoxInst *AllocBoxInst::create(SILDebugLocation Loc,
-                                   CanSILBoxType BoxType,
+AllocBoxInst *AllocBoxInst::create(SILDebugLocation Loc, CanSILBoxType BoxType,
                                    SILFunction &F,
                                    Optional<SILDebugVariable> Var,
-                                   bool hasDynamicLifetime,
-                                   bool reflection) {
+                                   bool hasDynamicLifetime, bool reflection,
+                                   bool usesMoveableValueDebugInfo) {
   SmallVector<SILValue, 8> TypeDependentOperands;
   collectTypeDependentOperands(TypeDependentOperands, F, BoxType);
   auto Sz = totalSizeToAlloc<swift::Operand, char>(TypeDependentOperands.size(),
                                                    Var ? Var->Name.size() : 0);
   auto Buf = F.getModule().allocateInst(Sz, alignof(AllocBoxInst));
-  return ::new (Buf) AllocBoxInst(Loc, BoxType, TypeDependentOperands, F, Var,
-                                  hasDynamicLifetime, reflection);
+  return ::new (Buf)
+      AllocBoxInst(Loc, BoxType, TypeDependentOperands, F, Var,
+                   hasDynamicLifetime, reflection, usesMoveableValueDebugInfo);
 }
 
 SILType AllocBoxInst::getAddressType() const {
diff --git a/lib/SIL/IR/SILPrinter.cpp b/lib/SIL/IR/SILPrinter.cpp
@@ -1434,6 +1434,11 @@ class SILPrinter : public SILInstructionVisitor<SILPrinter> {
     if (ABI->emitReflectionMetadata()) {
       *this << "[reflection] ";
     }
+
+    if (ABI->getUsesMoveableValueDebugInfo()) {
+      *this << "[moveable_value_debuginfo] ";
+    }
+
     *this << ABI->getType();
     printDebugVar(ABI->getVarInfo(),
                   &ABI->getModule().getASTContext().SourceMgr);
diff --git a/lib/SIL/Parser/ParseSIL.cpp b/lib/SIL/Parser/ParseSIL.cpp
@@ -2833,16 +2833,20 @@ bool SILParser::parseSpecificSILInstruction(SILBuilder &B,
   case SILInstructionKind::AllocBoxInst: {
     bool hasDynamicLifetime = false;
     bool hasReflection = false;
+    bool usesMoveableValueDebugInfo = false;
     StringRef attrName;
     SourceLoc attrLoc;
     while (parseSILOptional(attrName, attrLoc, *this)) {
       if (attrName.equals("dynamic_lifetime")) {
         hasDynamicLifetime = true;
       } else if (attrName.equals("reflection")) {
         hasReflection = true;
+      } else if (attrName.equals("moveable_value_debuginfo")) {
+        usesMoveableValueDebugInfo = true;
       } else {
-        P.diagnose(attrLoc, diag::sil_invalid_attribute_for_expected, attrName,
-                   "dynamic_lifetime or reflection");
+        P.diagnose(
+            attrLoc, diag::sil_invalid_attribute_for_expected, attrName,
+            "dynamic_lifetime, reflection, or usesMoveableValueDebugInfo");
       }
     }
 
@@ -2855,7 +2859,8 @@ bool SILParser::parseSpecificSILInstruction(SILBuilder &B,
     if (parseSILDebugLocation(InstLoc, B))
       return true;
     ResultVal = B.createAllocBox(InstLoc, Ty.castTo<SILBoxType>(), VarInfo,
-                                 hasDynamicLifetime, hasReflection);
+                                 hasDynamicLifetime, hasReflection,
+                                 usesMoveableValueDebugInfo);
     break;
   }
   case SILInstructionKind::ApplyInst:
diff --git a/lib/Serialization/DeserializeSIL.cpp b/lib/Serialization/DeserializeSIL.cpp
@@ -1308,13 +1308,16 @@ bool SILDeserializer::readSILInstruction(SILFunction *Fn,
   case SILInstructionKind::TestSpecificationInst:
     llvm_unreachable("not supported");
 
-  case SILInstructionKind::AllocBoxInst:
+  case SILInstructionKind::AllocBoxInst: {
     assert(RecordKind == SIL_ONE_TYPE && "Layout should be OneType.");
+    bool hasDynamicLifetime = Attr & 0x1;
+    bool reflection = (Attr >> 1) & 0x1;
+    bool usesMoveableValueDebugInfo = (Attr >> 2) & 0x1;
     ResultInst = Builder.createAllocBox(
         Loc, cast<SILBoxType>(MF->getType(TyID)->getCanonicalType()), None,
-        /*bool hasDynamicLifetime*/ Attr & 1,
-        /*bool reflection*/ Attr & 2);
+        hasDynamicLifetime, reflection, usesMoveableValueDebugInfo);
     break;
+  }
   case SILInstructionKind::AllocStackInst: {
     assert(RecordKind == SIL_ONE_TYPE && "Layout should be OneType.");
     bool hasDynamicLifetime = Attr & 0x1;
diff --git a/lib/Serialization/ModuleFormat.h b/lib/Serialization/ModuleFormat.h
@@ -58,7 +58,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 = 753; // distributed actor support for custom executors (NonDefaultDistributedActor type and mangling)
+const uint16_t SWIFTMODULE_VERSION_MINOR = 754; // allocbox move debug info
 
 /// A standard hash seed used for all string hashes in a serialized module.
 ///
diff --git a/lib/Serialization/SerializeSIL.cpp b/lib/Serialization/SerializeSIL.cpp
@@ -1034,9 +1034,10 @@ void SILSerializer::writeSILInstruction(const SILInstruction &SI) {
   }
   case SILInstructionKind::AllocBoxInst: {
     const AllocBoxInst *ABI = cast<AllocBoxInst>(&SI);
-    unsigned flags
-      = (ABI->hasDynamicLifetime() ? 1 : 0)
-      | (ABI->emitReflectionMetadata() ? 2 : 0);
+    unsigned flags = 0;
+    flags |= unsigned(ABI->hasDynamicLifetime());
+    flags |= unsigned(ABI->emitReflectionMetadata()) << 1;
+    flags |= unsigned(ABI->getUsesMoveableValueDebugInfo()) << 2;
     writeOneTypeLayout(ABI->getKind(),
                        flags,
                        ABI->getType());
diff --git a/test/SIL/Parser/basic2.sil b/test/SIL/Parser/basic2.sil
@@ -130,3 +130,14 @@ bb0(%0 : @owned $Builtin.NativeObject):
   %9999 = tuple()
   return %9999 : $()
 }
+
+// CHECK-LABEL: sil [ossa] @test_allocbox_moveable_value_debuginfo_flag : $@convention(thin) () -> () {
+// CHECK: alloc_box [moveable_value_debuginfo] ${ var Builtin.NativeObject }
+// CHECK: } // end sil function 'test_allocbox_moveable_value_debuginfo_flag'
+sil [ossa] @test_allocbox_moveable_value_debuginfo_flag : $@convention(thin) () -> () {
+bb0:
+  %0 = alloc_box [moveable_value_debuginfo] ${ var Builtin.NativeObject }
+  dealloc_box %0 : ${ var Builtin.NativeObject }
+  %9999 = tuple()
+  return %9999 : $()
+}
diff --git a/test/SIL/Serialization/basic2.sil b/test/SIL/Serialization/basic2.sil
@@ -6,6 +6,17 @@
 
 import Builtin
 
+// CHECK-LABEL: sil [ossa] @test_allocbox_moveable_value_debuginfo_flag : $@convention(thin) () -> () {
+// CHECK: alloc_box [moveable_value_debuginfo] ${ var Builtin.NativeObject }
+// CHECK: } // end sil function 'test_allocbox_moveable_value_debuginfo_flag'
+sil [ossa] @test_allocbox_moveable_value_debuginfo_flag : $@convention(thin) () -> () {
+bb0:
+  %0 = alloc_box [moveable_value_debuginfo] ${ var Builtin.NativeObject }
+  dealloc_box %0 : ${ var Builtin.NativeObject }
+  %9999 = tuple()
+  return %9999 : $()
+}
+
 // We don't serialize debug_value today... but we should.
 //
 // CHECK-LABEL: sil [ossa] @test_debug_value_alloc_stack_moved : $@convention(thin) (@owned Builtin.NativeObject) -> () {
