Merge pull request #73555 from Snowy1803/complete-getvarinfo

[DebugInfo] Return complete variable info from getVarInfo by default

Author: Snowy1803

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);
   }