[DebugInfo][SIL] Introduce the 'implicit' attribute for debug variable

Debug variables that are marked 'implicit' on its `debug_value`
instruction mean that they were generated by compiler. Optimizers are
free to remove them (if it becomes a dead code, for instance) even in
-Onone. Since they are barely used by users and keeping them might lead
to incorrect IRGen results.

Author: mshockwave

docs/SIL.rst

@@ -3505,6 +3505,7 @@ The operand must have loadable type.
    debug-var-attr ::= 'let'
    debug-var-attr ::= 'name' string-literal
    debug-var-attr ::= 'argno' integer-literal
+   debug-var-attr ::= 'implicit'
 
 ::
 
@@ -3520,12 +3521,13 @@ The operand must have loadable type.
 There are a number of attributes that provide details about the source
 variable that is being described, including the name of the
 variable. For function and closure arguments ``argno`` is the number
-of the function argument starting with 1. The advanced debug variable
-attributes represent source locations and type of the source variable
-when it was originally declared. It is useful when we're indirectly
-associating the SSA value with the source variable (via di-expression,
-for example) in which case SSA value's type is different from that of
-source variable.
+of the function argument starting with 1. A compiler-generated source
+variable will be marked ``implicit`` and optimizers are free to remove
+it even in -Onone. The advanced debug variable attributes represent source
+locations and type of the source variable when it was originally declared.
+It is useful when we're indirectly associating the SSA value with the
+source variable (via di-expression, for example) in which case SSA value's
+type is different from that of source variable.
 
 If the '[poison]' flag is set, then all references within this debug
 value will be overwritten with a sentinel at this point in the

include/swift/SIL/SILInstruction.h

@@ -1726,27 +1726,31 @@ struct SILDebugVariable {
   StringRef Name;
   unsigned ArgNo : 16;
   unsigned Constant : 1;
+  unsigned Implicit : 1;
   Optional<SILType> Type;
   Optional<SILLocation> Loc;
   const SILDebugScope *Scope;
   SILDebugInfoExpression DIExpr;
 
-  SILDebugVariable() : ArgNo(0), Constant(false), Scope(nullptr) {}
+  SILDebugVariable()
+      : ArgNo(0), Constant(false), Implicit(false), Scope(nullptr) {}
   SILDebugVariable(bool Constant, uint16_t ArgNo)
-      : ArgNo(ArgNo), Constant(Constant), Scope(nullptr) {}
+      : ArgNo(ArgNo), Constant(Constant), Implicit(false), Scope(nullptr) {}
   SILDebugVariable(StringRef Name, bool Constant, unsigned ArgNo,
-                   Optional<SILType> AuxType = {},
+                   bool IsImplicit = false, Optional<SILType> AuxType = {},
                    Optional<SILLocation> DeclLoc = {},
                    const SILDebugScope *DeclScope = nullptr,
                    llvm::ArrayRef<SILDIExprElement> ExprElements = {})
-      : Name(Name), ArgNo(ArgNo), Constant(Constant), Type(AuxType),
-        Loc(DeclLoc), Scope(DeclScope), DIExpr(ExprElements) {}
+      : Name(Name), ArgNo(ArgNo), Constant(Constant), Implicit(IsImplicit),
+        Type(AuxType), Loc(DeclLoc), Scope(DeclScope), DIExpr(ExprElements) {}
+
   // We're not comparing DIExpr here because strictly speaking,
   // DIExpr is not part of the debug variable. We simply piggyback
   // it in this class so that's it's easier to carry DIExpr around.
   bool operator==(const SILDebugVariable &V) {
     return ArgNo == V.ArgNo && Constant == V.Constant && Name == V.Name &&
-           Type == V.Type && Loc == V.Loc && Scope == V.Scope;
+           Implicit == V.Implicit && Type == V.Type && Loc == V.Loc &&
+           Scope == V.Scope;
   }
 };
 
@@ -1761,10 +1765,12 @@ 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 : 14;
+      int_type NameLength : 13;
       /// The source function argument position from left to right
       /// starting with 1 or 0 if this is a local variable.
       int_type ArgNo : 16;
@@ -1786,6 +1792,9 @@ 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; }
+
   Optional<SILDebugVariable>
   get(VarDecl *VD, const char *buf, Optional<SILType> AuxVarType = {},
       Optional<SILLocation> DeclLoc = {},
@@ -1796,11 +1805,11 @@ class TailAllocatedDebugVariable {
 
     if (VD)
       return SILDebugVariable(VD->getName().empty() ? "" : VD->getName().str(),
-                              VD->isLet(), getArgNo(), AuxVarType, DeclLoc,
-                              DeclScope, DIExprElements);
-    else
-      return SILDebugVariable(getName(buf), isLet(), getArgNo(), AuxVarType,
+                              VD->isLet(), getArgNo(), isImplicit(), AuxVarType,
                               DeclLoc, DeclScope, DIExprElements);
+    else
+      return SILDebugVariable(getName(buf), isLet(), getArgNo(), isImplicit(),
+                              AuxVarType, DeclLoc, DeclScope, DIExprElements);
   }
 };
 static_assert(sizeof(TailAllocatedDebugVariable) == 4,

lib/SIL/IR/SILInstructions.cpp

@@ -138,6 +138,7 @@ 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");
@@ -181,6 +182,11 @@ AllocStackInst::AllocStackInst(SILDebugLocation Loc, SILType elementType,
                                  getTrailingObjects<const SILDebugScope *>(),
                                  getTrailingObjects<SILDIExprElement>())
           .getRawValue();
+  if (auto *VD = Loc.getLocation().getAsASTNode<VarDecl>()) {
+    TailAllocatedDebugVariable DbgVar(SILNode::Bits.AllocStackInst.VarInfo);
+    DbgVar.setImplicit(VD->isImplicit() || DbgVar.isImplicit());
+    SILNode::Bits.AllocStackInst.VarInfo = DbgVar.getRawValue();
+  }
   TrailingOperandsList::InitOperandsList(getAllOperands().begin(), this,
                                          TypeDependentOperands);
 }
@@ -312,6 +318,8 @@ DebugValueInst::DebugValueInst(SILDebugLocation DebugLoc, SILValue Operand,
               getTrailingObjects<SILLocation>(),
               getTrailingObjects<const SILDebugScope *>(),
               getTrailingObjects<SILDIExprElement>()) {
+  if (auto *VD = DebugLoc.getLocation().getAsASTNode<VarDecl>())
+    VarInfo.setImplicit(VD->isImplicit() || VarInfo.isImplicit());
   setPoisonRefs(poisonRefs);
 }
 
@@ -331,7 +339,10 @@ DebugValueAddrInst::DebugValueAddrInst(SILDebugLocation DebugLoc,
       VarInfo(Var, getTrailingObjects<char>(), getTrailingObjects<SILType>(),
               getTrailingObjects<SILLocation>(),
               getTrailingObjects<const SILDebugScope *>(),
-              getTrailingObjects<SILDIExprElement>()) {}
+              getTrailingObjects<SILDIExprElement>()) {
+  if (auto *VD = DebugLoc.getLocation().getAsASTNode<VarDecl>())
+    VarInfo.setImplicit(VD->isImplicit() || VarInfo.isImplicit());
+}
 
 DebugValueAddrInst *DebugValueAddrInst::create(SILDebugLocation DebugLoc,
                                                SILValue Operand, SILModule &M,

lib/SIL/IR/SILPrinter.cpp

@@ -1198,6 +1198,8 @@ 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

@@ -1752,6 +1752,8 @@ 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

@@ -222,7 +222,11 @@ bool swift::hasOnlyEndOfScopeOrDestroyUses(SILInstruction *inst) {
       // Include debug uses only in Onone mode.
       if (isDebugUser && inst->getFunction()->getEffectiveOptimizationMode() <=
                              OptimizationMode::NoOptimization)
-        return false;
+        if (auto DbgVarInst = DebugVarCarryingInst(user)) {
+          auto VarInfo = DbgVarInst.getVarInfo();
+          if (VarInfo && !VarInfo->Implicit)
+            return false;
+        }
     }
   }
   return true;

test/DebugInfo/implicit_variable.swift

@@ -0,0 +1,12 @@
+// RUN: %target-swift-frontend -emit-sil -g %s -o %t.sil
+// RUN: %FileCheck %s --input-file=%t.sil
+// Test the SILParser / SILPrinter
+// RUN: %target-swift-frontend -module-name ImplicitVar -emit-sil -g %t.sil | %FileCheck %s
+
+struct MyStruct {
+    // Check if the 'implicit' directive for `self` is properly generated (and parsed)
+    // CHECK: sil {{.*}} @{{.*}}MyStructV5hello
+    // CHECK: debug_value %0 : $MyStruct
+    // CHECK-SAME:        let, name "self", argno 1, implicit, loc
+    func hello() {}
+}