[DebugInfo] Return complete variable info from getVarInfo by default

docs/HowToUpdateDebugInfo.md

@@ -108,6 +108,9 @@ debug_value %0 : $*T, let, name "address", type $UnsafeRawPointer
 The variable will usually have an associated expression yielding the correct
 type.
 
+> [!Note]
+> As there are no pointers in Swift, the type should never be an address type.
+
 ### Variable expressions
 
 A variable can have an associated expression if the value needs computation.

include/swift/SIL/DebugUtils.h

@@ -437,16 +437,24 @@ struct DebugVarCarryingInst : VarDeclCarryingInst {
 
   Kind getKind() const { return Kind(VarDeclCarryingInst::getKind()); }
 
-  std::optional<SILDebugVariable> getVarInfo() const {
+  /// Returns the debug variable information attached to the instruction.
+  ///
+  /// \param complete If true, always retrieve the complete variable with
+  /// location and scope, and the type if possible. If false, only return the
+  /// values if they are stored (if they are different from the instruction's
+  /// location, scope, and type). This should only be set to false in
+  /// SILPrinter. Incomplete var info is unpredictable, as it will sometimes
+  /// have location and scope and sometimes not.
+  std::optional<SILDebugVariable> getVarInfo(bool complete = true) const {
     switch (getKind()) {
     case Kind::Invalid:
       llvm_unreachable("Invalid?!");
     case Kind::DebugValue:
-      return cast<DebugValueInst>(**this)->getVarInfo();
+      return cast<DebugValueInst>(**this)->getVarInfo(complete);
     case Kind::AllocStack:
-      return cast<AllocStackInst>(**this)->getVarInfo();
+      return cast<AllocStackInst>(**this)->getVarInfo(complete);
     case Kind::AllocBox:
-      return cast<AllocBoxInst>(**this)->getVarInfo();
+      return cast<AllocBoxInst>(**this)->getVarInfo(complete);
     }
     llvm_unreachable("covered switch");
   }

include/swift/SIL/SILBuilder.h

@@ -425,7 +425,7 @@ class SILBuilder {
 #endif
     // Don't apply location overrides on variables.
     if (Var && !Var->Loc)
-      Var->Loc = Loc;
+      Var->Loc = Loc.strippedForDebugVariable();
     return insert(AllocStackInst::create(
         getSILDebugLocation(Loc, true), elementType, getFunction(),
         substituteAnonymousArgs(Name, Var, Loc), dynamic, isLexical,

include/swift/SIL/SILDebugInfoExpression.h

@@ -296,6 +296,16 @@ class SILDebugInfoExpression {
     return Elements.size() &&
            Elements[0].getAsOperator() == SILDIExprOperator::Dereference;
   }
+
+  /// Return the part of this SILDebugInfoExpression corresponding to fragments
+  SILDebugInfoExpression getFragmentPart() const {
+    for (auto it = element_begin(), end = element_end(); it != end; ++it) {
+      if (it->getAsOperator() == SILDIExprOperator::Fragment
+          || it->getAsOperator() == SILDIExprOperator::TupleFragment)
+        return SILDebugInfoExpression(ArrayRef(it, element_end()));
+    }
+    return {};
+  }
 };
 
 /// Returns the hashcode for the di expr element.

include/swift/SIL/SILInstruction.h

@@ -1875,9 +1875,9 @@ class TailAllocatedDebugVariable {
   bool isLet() const { return Bits.Data.Constant; }
 
   std::optional<SILDebugVariable>
-  get(VarDecl *VD, const char *buf, std::optional<SILType> AuxVarType = {},
-      std::optional<SILLocation> DeclLoc = {},
-      const SILDebugScope *DeclScope = nullptr,
+  get(VarDecl *VD, const char *buf, std::optional<SILType> AuxVarType,
+      std::optional<SILLocation> DeclLoc,
+      const SILDebugScope *DeclScope,
       llvm::ArrayRef<SILDIExprElement> DIExprElements = {}) const {
     if (!Bits.Data.HasValue)
       return std::nullopt;
@@ -2087,11 +2087,18 @@ class AllocStackInst final
   SILLocation getVarLoc() const {
     if (hasAuxDebugLocation())
       return *getTrailingObjects<SILLocation>();
-    return getLoc();
+    return getLoc().strippedForDebugVariable();
   }
 
   /// Return the debug variable information attached to this instruction.
-  std::optional<SILDebugVariable> getVarInfo() const {
+  ///
+  /// \param complete If true, always retrieve the complete variable with
+  /// location, scope, and element type. If false, only return the
+  /// values if they are stored (if they are different from the instruction's
+  /// location, scope, and type). This should only be set to false in
+  /// SILPrinter. Incomplete var info is unpredictable, as it will sometimes
+  /// have location and scope and sometimes not.
+  std::optional<SILDebugVariable> getVarInfo(bool complete = true) const {
     // If we used to have debug info attached but our debug info is now
     // invalidated, just bail.
     if (sharedUInt8().AllocStackInst.hasInvalidatedVarInfo) {
@@ -2103,11 +2110,18 @@ class AllocStackInst final
     const SILDebugScope *VarDeclScope = nullptr;
     if (HasAuxDebugVariableType)
       AuxVarType = *getTrailingObjects<SILType>();
+    else if (complete)
+      AuxVarType = getElementType();
 
     if (hasAuxDebugLocation())
       VarDeclLoc = *getTrailingObjects<SILLocation>();
+    else if (complete)
+      VarDeclLoc = getLoc().strippedForDebugVariable();
+
     if (hasAuxDebugScope())
       VarDeclScope = *getTrailingObjects<const SILDebugScope *>();
+    else if (complete)
+      VarDeclScope = getDebugScope();
 
     llvm::ArrayRef<SILDIExprElement> DIExprElements(
         getTrailingObjects<SILDIExprElement>(), NumDIExprOperands);
@@ -2509,8 +2523,13 @@ class AllocBoxInst final
   SILType getAddressType() const;
 
   /// Return the debug variable information attached to this instruction.
-  std::optional<SILDebugVariable> getVarInfo() const {
-    return VarInfo.get(getDecl(), getTrailingObjects<char>());
+  std::optional<SILDebugVariable> getVarInfo(bool complete = true) const {
+    if (complete)
+      return VarInfo.get(getDecl(), getTrailingObjects<char>(),
+                         getAddressType().getObjectType(),
+                         getLoc().strippedForDebugVariable(),
+                         getDebugScope());
+    return VarInfo.get(getDecl(), getTrailingObjects<char>(), {}, {}, nullptr);
   };
 
   void setUsesMoveableValueDebugInfo() {
@@ -5385,21 +5404,41 @@ class DebugValueInst final
   SILLocation getVarLoc() const {
     if (hasAuxDebugLocation())
       return *getTrailingObjects<SILLocation>();
-    return getLoc();
+    return getLoc().strippedForDebugVariable();
   }
 
   /// Return the debug variable information attached to this instruction.
-  std::optional<SILDebugVariable> getVarInfo() const {
+  ///
+  /// \param complete If true, always retrieve the complete variable with
+  /// location and scope, and the type if possible. If false, only return the
+  /// values if they are stored (if they are different from the instruction's
+  /// location, scope, and type). This should only be set to false in
+  /// SILPrinter. Incomplete var info is unpredictable, as it will sometimes
+  /// have location and scope and sometimes not.
+  ///
+  /// \note The type is not included because it can change during a pass.
+  /// Passes must make sure to not lose the type information.
+  std::optional<SILDebugVariable> getVarInfo(bool complete = true) const {
     std::optional<SILType> AuxVarType;
     std::optional<SILLocation> VarDeclLoc;
     const SILDebugScope *VarDeclScope = nullptr;
+
     if (HasAuxDebugVariableType)
       AuxVarType = *getTrailingObjects<SILType>();
+    // TODO: passes break if we set the type here, as the type of the operand
+    // can be changed during a pass.
+    // else if (complete)
+    //   AuxVarType = getOperand()->getType().getObjectType();
 
     if (hasAuxDebugLocation())
       VarDeclLoc = *getTrailingObjects<SILLocation>();
+    else if (complete)
+      VarDeclLoc = getLoc().strippedForDebugVariable();
+
     if (hasAuxDebugScope())
       VarDeclScope = *getTrailingObjects<const SILDebugScope *>();
+    else if (complete)
+      VarDeclScope = getDebugScope();
 
     llvm::ArrayRef<SILDIExprElement> DIExprElements(
         getTrailingObjects<SILDIExprElement>(), NumDIExprOperands);

include/swift/SIL/SILLocation.h

@@ -520,8 +520,13 @@ class SILLocation {
 };
 
 inline llvm::hash_code hash_value(const SILLocation &R) {
-  return llvm::hash_combine(R.kindAndFlags.packedKindAndFlags,
-                            *R.storage.filePositionLoc);
+  if (R.isFilenameAndLocation()) {
+    return llvm::hash_combine(R.kindAndFlags.packedKindAndFlags,
+                              *R.storage.filePositionLoc);
+  } else {
+    return llvm::hash_combine(R.kindAndFlags.packedKindAndFlags,
+                              R.storage.filePositionLoc);
+  }
 }
 
 inline llvm::hash_code hash_value(const SILLocation::FilenameAndLocation &R) {

lib/IRGen/IRGenSIL.cpp

@@ -679,7 +679,7 @@ class IRGenSILFunction :
     if (!VarInfo)
       return StringRef();
 
-    StringRef Name = i->getVarInfo()->Name;
+    StringRef Name = VarInfo->Name;
     // The $match variables generated by the type checker are not
     // guaranteed to be unique within their scope, but they have
     // unique VarDecls.

lib/SIL/IR/SILBasicBlock.cpp

@@ -342,8 +342,10 @@ transferNodesFromList(llvm::ilist_traits<SILBasicBlock> &SrcTraits,
 
       II.setDebugScope(ScopeCloner.getOrCreateClonedScope(II.getDebugScope()));
       // Special handling for SILDebugVariable.
+      // Fetch incomplete var info to avoid calling setDebugVarScope on
+      // alloc_box, crashing.
       if (auto DVI = DebugVarCarryingInst(&II))
-        if (auto VarInfo = DVI.getVarInfo())
+        if (auto VarInfo = DVI.getVarInfo(false))
           if (VarInfo->Scope)
             DVI.setDebugVarScope(
                 ScopeCloner.getOrCreateClonedScope(VarInfo->Scope));

lib/SIL/IR/SILInstructions.cpp

@@ -199,26 +199,10 @@ StringRef TailAllocatedDebugVariable::getName(const char *buf) const {
 
 std::optional<SILDebugVariable>
 SILDebugVariable::createFromAllocation(const AllocationInst *AI) {
-  std::optional<SILDebugVariable> VarInfo;
   if (const auto *ASI = dyn_cast_or_null<AllocStackInst>(AI))
-    VarInfo = ASI->getVarInfo();
+    return ASI->getVarInfo();
   // TODO: Support AllocBoxInst
-
-  if (!VarInfo)
-    return {};
-
-  // Coalesce the debug loc attached on AI into VarInfo
-  SILType Type = AI->getType();
-  SILLocation InstLoc = AI->getLoc();
-  const SILDebugScope *InstDS = AI->getDebugScope();
-  if (!VarInfo->Type)
-    VarInfo->Type = Type;
-  if (!VarInfo->Loc)
-    VarInfo->Loc = InstLoc;
-  if (!VarInfo->Scope)
-    VarInfo->Scope = InstDS;
-
-  return VarInfo;
+  return {};
 }
 
 AllocStackInst::AllocStackInst(
@@ -268,7 +252,7 @@ AllocStackInst *AllocStackInst::create(SILDebugLocation Loc,
                                        UsesMoveableValueDebugInfo_t wasMoved) {
   // Don't store the same information twice.
   if (Var) {
-    if (Var->Loc == Loc.getLocation())
+    if (Var->Loc == Loc.getLocation().strippedForDebugVariable())
       Var->Loc = {};
     if (Var->Scope == Loc.getScope())
       Var->Scope = nullptr;
@@ -473,7 +457,7 @@ DebugValueInst *DebugValueInst::create(SILDebugLocation DebugLoc,
                                        UsesMoveableValueDebugInfo_t wasMoved,
                                        bool trace) {
   // Don't store the same information twice.
-  if (Var.Loc == DebugLoc.getLocation())
+  if (Var.Loc == DebugLoc.getLocation().strippedForDebugVariable())
     Var.Loc = {};
   if (Var.Scope == DebugLoc.getScope())
     Var.Scope = nullptr;

lib/SIL/IR/SILPrinter.cpp

@@ -1446,7 +1446,7 @@ class SILPrinter : public SILInstructionVisitor<SILPrinter> {
     if (AVI->usesMoveableValueDebugInfo() && !AVI->getType().isMoveOnly())
       *this << "[moveable_value_debuginfo] ";
     *this << AVI->getElementType();
-    printDebugVar(AVI->getVarInfo(),
+    printDebugVar(AVI->getVarInfo(false),
                   &AVI->getModule().getASTContext().SourceMgr);
   }
   void visitAllocVectorInst(AllocVectorInst *AVI) {
@@ -1503,7 +1503,7 @@ class SILPrinter : public SILInstructionVisitor<SILPrinter> {
     }
 
     *this << ABI->getType();
-    printDebugVar(ABI->getVarInfo(),
+    printDebugVar(ABI->getVarInfo(false),
                   &ABI->getModule().getASTContext().SourceMgr);
   }
 
@@ -1915,7 +1915,7 @@ class SILPrinter : public SILInstructionVisitor<SILPrinter> {
     if (DVI->hasTrace())
       *this << "[trace] ";
     *this << getIDAndType(DVI->getOperand());
-    printDebugVar(DVI->getVarInfo(),
+    printDebugVar(DVI->getVarInfo(false),
                   &DVI->getModule().getASTContext().SourceMgr);
   }
 

lib/SIL/Verifier/SILVerifier.cpp

@@ -1486,39 +1486,34 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
 
   void checkDebugVariable(SILInstruction *inst) {
     std::optional<SILDebugVariable> varInfo;
-    if (auto *di = dyn_cast<AllocStackInst>(inst))
-      varInfo = di->getVarInfo();
-    else if (auto *di = dyn_cast<AllocBoxInst>(inst))
-      varInfo = di->getVarInfo();
-    else if (auto *di = dyn_cast<DebugValueInst>(inst))
-      varInfo = di->getVarInfo();
+    if (auto di = DebugVarCarryingInst(inst))
+      varInfo = di.getVarInfo();
 
     if (!varInfo)
       return;
 
     // Retrieve debug variable type
-    SILType DebugVarTy;
-    if (varInfo->Type)
-      DebugVarTy = *varInfo->Type;
-    else {
-      // Fetch from related SSA value
-      switch (inst->getKind()) {
-      case SILInstructionKind::AllocStackInst:
-      case SILInstructionKind::AllocBoxInst:
-        DebugVarTy = inst->getResult(0)->getType();
-        break;
-      case SILInstructionKind::DebugValueInst:
-        DebugVarTy = inst->getOperand(0)->getType();
-        if (DebugVarTy.isAddress()) {
-          // FIXME: op_deref could be applied to address types only.
-          // FIXME: Add this check
-          if (varInfo->DIExpr.startsWithDeref())
-            DebugVarTy = DebugVarTy.getObjectType();
-        }
-        break;
-      default:
-        llvm_unreachable("impossible instruction kind");
-      }
+    SILType SSAType;
+    switch (inst->getKind()) {
+    case SILInstructionKind::AllocStackInst:
+    case SILInstructionKind::AllocBoxInst:
+      // TODO: unwrap box for AllocBox
+      SSAType = inst->getResult(0)->getType().getObjectType();
+      break;
+    case SILInstructionKind::DebugValueInst:
+      SSAType = inst->getOperand(0)->getType();
+      break;
+    default:
+      llvm_unreachable("impossible instruction kind");
+    }
+
+    SILType DebugVarTy = varInfo->Type ? *varInfo->Type :
+      SSAType.getObjectType();
+    if (!varInfo->DIExpr && !isa<AllocBoxInst>(inst)) {
+      // FIXME: Remove getObjectType() below when we fix create/createAddr
+      require(DebugVarTy.removingMoveOnlyWrapper()
+              == SSAType.getObjectType().removingMoveOnlyWrapper(),
+              "debug type mismatch without a DIExpr");
     }
 
     auto *debugScope = inst->getDebugScope();

lib/SILOptimizer/Differentiation/Common.cpp

@@ -266,12 +266,12 @@ void collectMinimalIndicesForFunctionCall(
 std::optional<std::pair<SILDebugLocation, SILDebugVariable>>
 findDebugLocationAndVariable(SILValue originalValue) {
   if (auto *asi = dyn_cast<AllocStackInst>(originalValue))
-    return swift::transform(asi->getVarInfo(),  [&](SILDebugVariable var) {
+    return swift::transform(asi->getVarInfo(false),  [&](SILDebugVariable var) {
       return std::make_pair(asi->getDebugLocation(), var);
     });
   for (auto *use : originalValue->getUses()) {
     if (auto *dvi = dyn_cast<DebugValueInst>(use->getUser()))
-      return swift::transform(dvi->getVarInfo(), [&](SILDebugVariable var) {
+      return swift::transform(dvi->getVarInfo(false), [&](SILDebugVariable var) {
         // We need to drop `op_deref` here as we're transferring debug info
         // location from debug_value instruction (which describes how to get value)
         // into alloc_stack (which describes the location)

lib/SILOptimizer/Differentiation/JVPCloner.cpp

@@ -1000,9 +1000,16 @@ class JVPCloner::Implementation final
   ///    Tangent: tan[y] = alloc_stack $T.Tangent
   CLONE_AND_EMIT_TANGENT(AllocStack, asi) {
     auto &diffBuilder = getDifferentialBuilder();
+    auto varInfo = asi->getVarInfo();
+    if (varInfo) {
+      // This is a new variable, it shouldn't keep the old scope, type, etc.
+      varInfo->Type = {};
+      varInfo->DIExpr = {};
+      varInfo->Loc = {};
+      varInfo->Scope = nullptr;
+    }
     auto *mappedAllocStackInst = diffBuilder.createAllocStack(
-        asi->getLoc(), getRemappedTangentType(asi->getElementType()),
-        asi->getVarInfo());
+        asi->getLoc(), getRemappedTangentType(asi->getElementType()), varInfo);
     setTangentBuffer(asi->getParent(), asi, mappedAllocStackInst);
   }
 

lib/SILOptimizer/Differentiation/PullbackCloner.cpp

@@ -665,6 +665,11 @@ class PullbackCloner::Implementation final
             }
             adjNameStream << " (scope #" << origBB->getDebugID() << ")";
             dv.Name = adjName;
+            // We have no meaningful debug location, and the type is different.
+            dv.Scope = nullptr;
+            dv.Loc = {};
+            dv.Type = {};
+            dv.DIExpr = {};
             return dv;
           }));
     return (insertion.first->getSecond() = newBuf);