Merge pull request swiftlang#73011 from Snowy1803/6.0-salvage-debug-info-tuple

[6.0] [DebugInfo] Salvage debug info for tuples

Author: Snowy1803

docs/SIL.rst

@@ -4297,7 +4297,6 @@ less verbose.
    debug-var-attr ::= 'let'
    debug-var-attr ::= 'name' string-literal
    debug-var-attr ::= 'argno' integer-literal
-   debug-var-attr ::= 'implicit'
 
 There are a number of attributes that provide details about the source
 variable that is being described, including the name of the

include/swift/SIL/SILDebugVariable.h

@@ -38,7 +38,6 @@ struct SILDebugVariable {
   StringRef Name;
   unsigned ArgNo : 16;
   unsigned Constant : 1;
-  unsigned Implicit : 1;
   unsigned isDenseMapSingleton : 2;
   std::optional<SILType> Type;
   std::optional<SILLocation> Loc;
@@ -58,17 +57,17 @@ struct SILDebugVariable {
   }
 
   SILDebugVariable()
-      : ArgNo(0), Constant(false), Implicit(false), isDenseMapSingleton(0),
+      : ArgNo(0), Constant(false),  isDenseMapSingleton(0),
         Scope(nullptr) {}
   SILDebugVariable(bool Constant, uint16_t ArgNo)
-      : ArgNo(ArgNo), Constant(Constant), Implicit(false),
+      : ArgNo(ArgNo), Constant(Constant),
         isDenseMapSingleton(0), Scope(nullptr) {}
   SILDebugVariable(StringRef Name, bool Constant, unsigned ArgNo,
-                   bool IsImplicit = false, std::optional<SILType> AuxType = {},
+                   std::optional<SILType> AuxType = {},
                    std::optional<SILLocation> DeclLoc = {},
                    const SILDebugScope *DeclScope = nullptr,
                    llvm::ArrayRef<SILDIExprElement> ExprElements = {})
-      : Name(Name), ArgNo(ArgNo), Constant(Constant), Implicit(IsImplicit),
+      : Name(Name), ArgNo(ArgNo), Constant(Constant),
         isDenseMapSingleton(0), Type(AuxType), Loc(DeclLoc), Scope(DeclScope),
         DIExpr(ExprElements) {}
 
@@ -85,9 +84,8 @@ struct SILDebugVariable {
   // it in this class so that's it's easier to carry DIExpr around.
   bool operator==(const SILDebugVariable &V) const {
     return ArgNo == V.ArgNo && Constant == V.Constant && Name == V.Name &&
-           Implicit == V.Implicit && Type == V.Type && Loc == V.Loc &&
-           Scope == V.Scope && isDenseMapSingleton == V.isDenseMapSingleton &&
-           DIExpr == V.DIExpr;
+           Type == V.Type && Loc == V.Loc && Scope == V.Scope &&
+           isDenseMapSingleton == V.isDenseMapSingleton && DIExpr == V.DIExpr;
   }
 
   SILDebugVariable withoutDIExpr() const {
@@ -103,7 +101,7 @@ struct SILDebugVariable {
 
 /// Returns the hashcode for the new projection path.
 inline llvm::hash_code hash_value(const SILDebugVariable &P) {
-  return llvm::hash_combine(P.ArgNo, P.Constant, P.Name, P.Implicit,
+  return llvm::hash_combine(P.ArgNo, P.Constant, P.Name,
                             P.isDenseMapSingleton, P.Type, P.Loc, P.Scope,
                             P.DIExpr);
 }

include/swift/SIL/SILInstruction.h

@@ -1849,12 +1849,10 @@ class TailAllocatedDebugVariable {
       int_type HasValue : 1;
       /// True if this is a let-binding.
       int_type Constant : 1;
-      /// True if this variable is created by compiler
-      int_type Implicit : 1;
       /// When this is nonzero there is a tail-allocated string storing
       /// variable name present. This typically only happens for
       /// instructions that were created from parsing SIL assembler.
-      int_type NameLength : 13;
+      int_type NameLength : 14;
       /// The source function argument position from left to right
       /// starting with 1 or 0 if this is a local variable.
       int_type ArgNo : 16;
@@ -1876,9 +1874,6 @@ class TailAllocatedDebugVariable {
   StringRef getName(const char *buf) const;
   bool isLet() const { return Bits.Data.Constant; }
 
-  bool isImplicit() const { return Bits.Data.Implicit; }
-  void setImplicit(bool V = true) { Bits.Data.Implicit = V; }
-
   std::optional<SILDebugVariable>
   get(VarDecl *VD, const char *buf, std::optional<SILType> AuxVarType = {},
       std::optional<SILLocation> DeclLoc = {},
@@ -1890,8 +1885,8 @@ class TailAllocatedDebugVariable {
     StringRef name = getName(buf);
     if (VD && name.empty())
       name = VD->getName().str();
-    return SILDebugVariable(name, isLet(), getArgNo(), isImplicit(), AuxVarType,
-                            DeclLoc, DeclScope, DIExprElements);
+    return SILDebugVariable(name, isLet(), getArgNo(), AuxVarType, DeclLoc,
+                            DeclScope, DIExprElements);
   }
 };
 static_assert(sizeof(TailAllocatedDebugVariable) == 4,

lib/SIL/IR/SILInstructions.cpp

@@ -175,7 +175,6 @@ TailAllocatedDebugVariable::TailAllocatedDebugVariable(
   Bits.Data.HasValue = true;
   Bits.Data.Constant = Var->Constant;
   Bits.Data.ArgNo = Var->ArgNo;
-  Bits.Data.Implicit = Var->Implicit;
   Bits.Data.NameLength = Var->Name.size();
   assert(Bits.Data.ArgNo == Var->ArgNo && "Truncation");
   assert(Bits.Data.NameLength == Var->Name.size() && "Truncation");
@@ -256,10 +255,6 @@ AllocStackInst::AllocStackInst(
   assert(sharedUInt32().AllocStackInst.numOperands ==
              TypeDependentOperands.size() &&
          "Truncation");
-  auto *VD = Loc.getLocation().getAsASTNode<VarDecl>();
-  if (Var && VD) {
-    VarInfo.setImplicit(VD->isImplicit() || VarInfo.isImplicit());
-  }
   TrailingOperandsList::InitOperandsList(getAllOperands().begin(), this,
                                          TypeDependentOperands);
 }
@@ -454,8 +449,6 @@ DebugValueInst::DebugValueInst(
               getTrailingObjects<SILLocation>(),
               getTrailingObjects<const SILDebugScope *>(),
               getTrailingObjects<SILDIExprElement>()) {
-  if (auto *VD = DebugLoc.getLocation().getAsASTNode<VarDecl>())
-    VarInfo.setImplicit(VD->isImplicit() || VarInfo.isImplicit());
   setPoisonRefs(poisonRefs);
   if (usesMoveableValueDebugInfo || Operand->getType().isMoveOnly())
     setUsesMoveableValueDebugInfo();

lib/SIL/IR/SILPrinter.cpp

@@ -1424,8 +1424,6 @@ class SILPrinter : public SILInstructionVisitor<SILPrinter> {
 
       if (Var->ArgNo)
         *this << ", argno " << Var->ArgNo;
-      if (Var->Implicit)
-        *this << ", implicit";
       if (Var->Type) {
         *this << ", type ";
         Var->Type->print(PrintState.OS, PrintState.ASTOptions);

lib/SIL/Parser/ParseSIL.cpp

@@ -1677,8 +1677,6 @@ bool SILParser::parseSILDebugVar(SILDebugVariable &Var) {
       Var.Constant = false;
     } else if (Key == "loc") {
       Var.Constant = false;
-    } else if (Key == "implicit") {
-      Var.Implicit = true;
     } else {
       P.diagnose(P.Tok, diag::sil_dbg_unknown_key, Key);
       return true;

lib/SILOptimizer/Utils/InstOptUtils.cpp

@@ -238,11 +238,7 @@ bool swift::hasOnlyEndOfScopeOrEndOfLifetimeUses(SILInstruction *inst) {
       // Include debug uses only in Onone mode.
       if (isDebugUser && inst->getFunction()->getEffectiveOptimizationMode() <=
                              OptimizationMode::NoOptimization)
-        if (auto DbgVarInst = DebugVarCarryingInst(user)) {
-          auto VarInfo = DbgVarInst.getVarInfo();
-          if (VarInfo && !VarInfo->Implicit)
-            return false;
-        }
+        return false;
     }
   }
   return true;
@@ -1848,8 +1844,8 @@ void swift::salvageDebugInfo(SILInstruction *I) {
   }
   // If a `struct` SIL instruction is "unwrapped" and removed,
   // for instance, in favor of using its enclosed value directly,
-  // we need to make sure any of its related `debug_value` instruction
-  // is preserved.
+  // we need to make sure any of its related `debug_value` instructions
+  // are preserved.
   if (auto *STI = dyn_cast<StructInst>(I)) {
     auto STVal = STI->getResult(0);
     llvm::ArrayRef<VarDecl *> FieldDecls =
@@ -1875,6 +1871,31 @@ void swift::salvageDebugInfo(SILInstruction *I) {
       }
     }
   }
+  // Similarly, if a `tuple` SIL instruction is "unwrapped" and removed,
+  // we need to make sure any of its related `debug_value` instructions
+  // are preserved.
+  if (auto *TTI = dyn_cast<TupleInst>(I)) {
+    auto TTVal = TTI->getResult(0);
+    for (Operand *U : getDebugUses(TTVal)) {
+      auto *DbgInst = cast<DebugValueInst>(U->getUser());
+      auto VarInfo = DbgInst->getVarInfo();
+      if (!VarInfo)
+        continue;
+      TupleType *TT = TTI->getTupleType();
+      for (auto i : indices(TT->getElements())) {
+        SILDebugVariable NewVarInfo = *VarInfo;
+        auto FragDIExpr = SILDebugInfoExpression::createTupleFragment(TT, i);
+        NewVarInfo.DIExpr.append(FragDIExpr);
+
+        if (!NewVarInfo.Type)
+          NewVarInfo.Type = TTI->getType();
+
+        // Create a new debug_value
+        SILBuilder(TTI, DbgInst->getDebugScope())
+          .createDebugValue(DbgInst->getLoc(), TTI->getElement(i), NewVarInfo);
+      }
+    }
+  }
 
   if (auto *IA = dyn_cast<IndexAddrInst>(I)) {
     if (IA->getBase() && IA->getIndex())

test/AutoDiff/compiler_crashers_fixed/58660-conflicting-debug-info-inlining.swift

@@ -45,9 +45,9 @@ struct MyModel: Differentiable {
   @differentiable(reverse)
   mutating func member4() {
 // CHECK-LABEL: // pullback of MyModel.member4()
-// CHECK-NOT: debug_value %{{.*}} : $MyModel.TangentVector, var, name %{{.*}}, argno 1, implicit, scope
+// CHECK-NOT: debug_value %{{.*}} : $MyModel.TangentVector, var, name %{{.*}}, argno 1, scope
 // CHECK: bb0(%{{.*}} : $_AD__$s4main7MyModelV7member4yyF_bb3__Pred__src_0_wrt_0):
-// CHECK: debug_value %{{.*}} : $MyModel.TangentVector, var, name "derivative of 'self' in scope at {{.*}} (scope #1)", implicit, scope
+// CHECK: debug_value %{{.*}} : $MyModel.TangentVector, var, name "derivative of 'self' in scope at {{.*}} (scope #1)", scope
     // Must be a differentiable type.
     var localVar: Float = 0
 

test/Concurrency/transfernonsendable.sil

@@ -287,7 +287,7 @@ bb3(%4 : @owned $FakeOptional<NonSendableKlass>):
 
 sil [ossa] @warningIfCallingGetter : $@convention(method) @async (@sil_isolated @guaranteed MyActor) -> () {
 bb0(%0 : @guaranteed $MyActor):
-  debug_value %0 : $MyActor, let, name "self", argno 1, implicit
+  debug_value %0 : $MyActor, let, name "self", argno 1
   hop_to_executor %0 : $MyActor
   %3 = class_method %0 : $MyActor, #MyActor.klass!getter : (isolated MyActor) -> () -> NonSendableKlass, $@convention(method) (@sil_isolated @guaranteed MyActor) -> @owned NonSendableKlass
   %4 = apply %3(%0) : $@convention(method) (@sil_isolated @guaranteed MyActor) -> @owned NonSendableKlass
@@ -301,7 +301,7 @@ bb0(%0 : @guaranteed $MyActor):
 
 sil [ossa] @assignIntoSetter : $@convention(method) @async (@sil_isolated @guaranteed MyActor) -> () {
 bb0(%0 : @guaranteed $MyActor):
-  debug_value %0 : $MyActor, let, name "self", argno 1, implicit
+  debug_value %0 : $MyActor, let, name "self", argno 1
   hop_to_executor %0 : $MyActor
   %4 = function_ref @constructNonSendableKlass : $@convention(thin) () -> @owned NonSendableKlass
   %5 = apply %4() : $@convention(thin) () -> @owned NonSendableKlass

test/Concurrency/transfernonsendable_instruction_matching.sil

@@ -1680,7 +1680,7 @@ bb0(%arg : $Builtin.Word):
 
 sil hidden [ossa] @test_unconditional_checked_cast : $@convention(method) (@guaranteed ChildClass) -> @owned ChildClass {
 bb0(%0 : @guaranteed $ChildClass):
-  debug_value %0 : $ChildClass, let, name "self", argno 1, implicit
+  debug_value %0 : $ChildClass, let, name "self", argno 1
   %2 = copy_value %0 : $ChildClass
   %3 = upcast %2 : $ChildClass to $ParentClass
   %4 = function_ref @copyParentClass : $@convention(thin) (@guaranteed ParentClass) -> @owned ParentClass
@@ -1693,4 +1693,4 @@ bb0(%0 : @guaranteed $ChildClass):
   %11 = copy_value %8 : $ChildClass
   destroy_value %8 : $ChildClass
   return %11 : $ChildClass
-}
+}