[SIL][DebugInfo] PATCH 3/3: Deprecate debug_value_addr SIL instruciton

This patch removes all references to DebugValueAddrInst class and
debug_value_addr instruction in textual SIL files.

Author: mshockwave

include/swift/SIL/DebugUtils.h

@@ -11,7 +11,7 @@
 //===----------------------------------------------------------------------===//
 //
 // This file contains utilities to work with debug-info related instructions:
-// debug_value and debug_value_addr.
+// debug_value, alloc_stack, and alloc_box.
 //
 // SIL optimizations should deal with debug-info related instructions when
 // looking at the uses of a value.
@@ -228,7 +228,6 @@ struct DebugVarCarryingInst {
   enum class Kind {
     Invalid = 0,
     DebugValue,
-    DebugValueAddr,
     AllocStack,
     AllocBox,
   };
@@ -239,8 +238,6 @@ struct DebugVarCarryingInst {
   DebugVarCarryingInst() : kind(Kind::Invalid), inst(nullptr) {}
   DebugVarCarryingInst(DebugValueInst *dvi)
       : kind(Kind::DebugValue), inst(dvi) {}
-  DebugVarCarryingInst(DebugValueAddrInst *dvai)
-      : kind(Kind::DebugValueAddr), inst(dvai) {}
   DebugVarCarryingInst(AllocStackInst *asi)
       : kind(Kind::AllocStack), inst(asi) {}
   DebugVarCarryingInst(AllocBoxInst *abi) : kind(Kind::AllocBox), inst(abi) {}
@@ -252,9 +249,6 @@ struct DebugVarCarryingInst {
     case SILInstructionKind::DebugValueInst:
       kind = Kind::DebugValue;
       break;
-    case SILInstructionKind::DebugValueAddrInst:
-      kind = Kind::DebugValueAddr;
-      break;
     case SILInstructionKind::AllocStackInst:
       kind = Kind::AllocStack;
       break;
@@ -283,8 +277,6 @@ struct DebugVarCarryingInst {
       llvm_unreachable("Invalid?!");
     case Kind::DebugValue:
       return cast<DebugValueInst>(inst)->getDecl();
-    case Kind::DebugValueAddr:
-      return cast<DebugValueAddrInst>(inst)->getDecl();
     case Kind::AllocStack:
       return cast<AllocStackInst>(inst)->getDecl();
     case Kind::AllocBox:
@@ -299,8 +291,6 @@ struct DebugVarCarryingInst {
       llvm_unreachable("Invalid?!");
     case Kind::DebugValue:
       return cast<DebugValueInst>(inst)->getVarInfo();
-    case Kind::DebugValueAddr:
-      return cast<DebugValueAddrInst>(inst)->getVarInfo();
     case Kind::AllocStack:
       return cast<AllocStackInst>(inst)->getVarInfo();
     case Kind::AllocBox:
@@ -316,9 +306,6 @@ struct DebugVarCarryingInst {
     case Kind::DebugValue:
       cast<DebugValueInst>(inst)->setDebugVarScope(NewDS);
       break;
-    case Kind::DebugValueAddr:
-      cast<DebugValueAddrInst>(inst)->setDebugVarScope(NewDS);
-      break;
     case Kind::AllocStack:
       cast<AllocStackInst>(inst)->setDebugVarScope(NewDS);
       break;

include/swift/SIL/Projection.h

@@ -859,7 +859,7 @@ class ProjectionTree {
   ProjectionTree &operator=(ProjectionTree &&) = default;
 
   /// Compute liveness and use information in this projection tree using Base.
-  /// All debug instructions (debug_value, debug_value_addr) are ignored.
+  /// All debug_value instructions are ignored.
   void computeUsesAndLiveness(SILValue Base);
 
   /// Create a root SILValue iout of the given leaf node values by walking on

include/swift/SIL/SILBuilder.h

@@ -930,7 +930,7 @@ class SILBuilder {
   DebugValueInst *createDebugValueAddr(SILLocation Loc, SILValue src,
                                        SILDebugVariable Var);
 
-  /// Create a debug_value_addr if \p src is an address; a debug_value if not.
+  /// Create a debug_value according to the type of \p src
   SILInstruction *emitDebugDescription(SILLocation Loc, SILValue src,
                                        SILDebugVariable Var) {
     if (src->getType().isAddress())

include/swift/SIL/SILCloner.h

@@ -1254,24 +1254,6 @@ SILCloner<ImplClass>::visitDebugValueInst(DebugValueInst *Inst) {
   remapDebugVarInfo(DebugVarCarryingInst(NewInst));
   recordClonedInstruction(Inst, NewInst);
 }
-template<typename ImplClass>
-void
-SILCloner<ImplClass>::visitDebugValueAddrInst(DebugValueAddrInst *Inst) {
-  // We cannot inline/clone debug intrinsics without a scope. If they
-  // describe function arguments there is no way to determine which
-  // function they belong to.
-  if (!Inst->getDebugScope())
-    return;
-
-  // Do not remap the location for a debug Instruction.
-  SILDebugVariable VarInfo = *Inst->getVarInfo();
-  SILValue OpValue = getOpValue(Inst->getOperand());
-  getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));
-  auto *NewInst = getBuilder().createDebugValueAddr(Inst->getLoc(), OpValue,
-                                                    *Inst->getVarInfo());
-  remapDebugVarInfo(DebugVarCarryingInst(NewInst));
-  recordClonedInstruction(Inst, NewInst);
-}
 
 #define NEVER_LOADABLE_CHECKED_REF_STORAGE(Name, name, ...)                    \
   template <typename ImplClass>                                                \

include/swift/SIL/SILInstruction.h

@@ -734,8 +734,7 @@ class SILInstruction : public llvm::ilist_node<SILInstruction> {
   /// Returns true if the instruction is only relevant for debug
   /// informations and has no other impact on program semantics.
   bool isDebugInstruction() const {
-    return getKind() == SILInstructionKind::DebugValueInst ||
-           getKind() == SILInstructionKind::DebugValueAddrInst;
+    return getKind() == SILInstructionKind::DebugValueInst;
   }
 
   /// Returns true if the instruction is a meta instruction which is
@@ -1720,8 +1719,8 @@ class UnaryInstructionWithTypeDependentOperandsBase
 };
 
 /// Holds common debug information about local variables and function
-/// arguments that are needed by DebugValueInst, DebugValueAddrInst,
-/// AllocStackInst, and AllocBoxInst.
+/// arguments that are needed by DebugValueInst, AllocStackInst,
+/// and AllocBoxInst.
 struct SILDebugVariable {
   StringRef Name;
   unsigned ArgNo : 16;
@@ -4741,58 +4740,6 @@ class DebugValueInst final
   }
 };
 
-/// Define the start or update to a symbolic variable value (for address-only
-/// types) .
-class DebugValueAddrInst final
-    : public UnaryInstructionBase<SILInstructionKind::DebugValueAddrInst,
-                                  NonValueInstruction>,
-      private SILDebugVariableSupplement,
-      private llvm::TrailingObjects<DebugValueAddrInst, SILType, SILLocation,
-                                    const SILDebugScope *, SILDIExprElement,
-                                    char> {
-  friend TrailingObjects;
-  friend SILBuilder;
-
-  TailAllocatedDebugVariable VarInfo;
-
-  DebugValueAddrInst(SILDebugLocation DebugLoc, SILValue Operand,
-                     SILDebugVariable Var);
-  static DebugValueAddrInst *create(SILDebugLocation DebugLoc,
-                                    SILValue Operand, SILModule &M,
-                                    SILDebugVariable Var);
-
-  SIL_DEBUG_VAR_SUPPLEMENT_TRAILING_OBJS_IMPL()
-
-public:
-  /// Return the underlying variable declaration that this denotes,
-  /// or null if we don't have one.
-  VarDecl *getDecl() const;
-  /// Return the debug variable information attached to this instruction.
-  Optional<SILDebugVariable> getVarInfo() const {
-    Optional<SILType> AuxVarType;
-    Optional<SILLocation> VarDeclLoc;
-    const SILDebugScope *VarDeclScope = nullptr;
-    if (HasAuxDebugVariableType)
-      AuxVarType = *getTrailingObjects<SILType>();
-
-    if (hasAuxDebugLocation())
-      VarDeclLoc = *getTrailingObjects<SILLocation>();
-    if (hasAuxDebugScope())
-      VarDeclScope = *getTrailingObjects<const SILDebugScope *>();
-
-    llvm::ArrayRef<SILDIExprElement> DIExprElements(
-        getTrailingObjects<SILDIExprElement>(), NumDIExprOperands);
-
-    return VarInfo.get(getDecl(), getTrailingObjects<char>(), AuxVarType,
-                       VarDeclLoc, VarDeclScope, DIExprElements);
-  }
-
-  void setDebugVarScope(const SILDebugScope *NewDS) {
-    if (hasAuxDebugScope())
-      *getTrailingObjects<const SILDebugScope *>() = NewDS;
-  }
-};
-
 /// An abstract class representing a load from some kind of reference storage.
 template <SILInstructionKind K>
 class LoadReferenceInstBase

include/swift/SIL/SILNodes.def

@@ -875,8 +875,6 @@ NON_VALUE_INST(MarkFunctionEscapeInst, mark_function_escape,
                SILInstruction, None, DoesNotRelease)
 BRIDGED_NON_VALUE_INST(DebugValueInst, debug_value,
                SILInstruction, None, DoesNotRelease)
-BRIDGED_NON_VALUE_INST(DebugValueAddrInst, debug_value_addr,
-               SILInstruction, None, DoesNotRelease)
 #define NEVER_OR_SOMETIMES_LOADABLE_CHECKED_REF_STORAGE(Name, name, ...) \
   NON_VALUE_INST(Store##Name##Inst, store_##name, \
                  SILInstruction, MayWrite, DoesNotRelease)

include/swift/SILOptimizer/Utils/CanonicalOSSALifetime.h

@@ -27,14 +27,14 @@
 ///     bb0(%arg : @owned $T, %addr : @trivial $*T):
 ///       %copy = copy_value %arg : $T
 ///       store %copy to [init] %addr : $*T
-///       debug_value_addr %addr : $*T
+///       debug_value %addr : $*T, expr op_deref
 ///       destroy_value %arg : $T
 ///
 /// Will be transformed to:
 ///
 ///     bb0(%arg : @owned $T, %addr : @trivial $*T):
 ///       store %copy to [init] %addr : $*T
-///       debug_value_addr %addr : $*T
+///       debug_value %addr : $*T, expr op_deref
 ///
 /// Example #2: Destroys are hoisted to the last use. Copies are inserted only
 /// at consumes within the lifetime (to directly satisfy ownership conventions):
@@ -43,7 +43,7 @@
 ///       %copy1 = copy_value %arg : $T
 ///       store %arg to [init] %addr : $*T
 ///       %_ = apply %_(%copy1) : $@convention(thin) (@guaranteed T) -> ()
-///       debug_value_addr %addr : $*T
+///       debug_value %addr : $*T, expr op_deref
 ///       destroy_value %copy1 : $T
 ///
 /// Will be transformed to:
@@ -53,7 +53,7 @@
 ///       store %copy1 to [init] %addr : $*T
 ///       %_ = apply %_(%arg) : $@convention(thin) (@guaranteed T) -> ()
 ///       destroy_value %arg : $T
-///       debug_value_addr %addr : $*T
+///       debug_value %addr : $*T, expr op_deref
 ///
 /// Example #3: Handle control flow.
 ///

include/swift/SILOptimizer/Utils/DebugOptUtils.h

@@ -44,8 +44,7 @@ inline void deleteAllDebugUses(SILInstruction *inst,
 }
 
 /// Transfer debug info associated with (the result of) \p I to a
-/// new `debug_value` or `debug_value_addr` instruction before \p I is
-/// deleted.
+/// new `debug_value` instruction before \p I is deleted.
 void salvageDebugInfo(SILInstruction *I);
 
 /// Erases the instruction \p I from it's parent block and deletes it, including

lib/IRGen/IRGenSIL.cpp

@@ -1146,7 +1146,6 @@ class IRGenSILFunction :
     llvm_unreachable("unimplemented");
   }
   void visitDebugValueInst(DebugValueInst *i);
-  void visitDebugValueAddrInst(DebugValueAddrInst *i);
   void visitRetainValueInst(RetainValueInst *i);
   void visitRetainValueAddrInst(RetainValueAddrInst *i);
   void visitCopyValueInst(CopyValueInst *i);
@@ -4792,64 +4791,6 @@ void IRGenSILFunction::visitDebugValueInst(DebugValueInst *i) {
                                i->getLoc(), *VarInfo, Indirection);
 }
 
-void IRGenSILFunction::visitDebugValueAddrInst(DebugValueAddrInst *i) {
-  if (i->getDebugScope()->getInlinedFunction()->isTransparent())
-    return;
-
-  auto SILVal = i->getOperand();
-  if (isa<SILUndef>(SILVal))
-    return;
-
-  auto VarInfo = i->getVarInfo();
-  assert(VarInfo && "debug_value_addr without debug info");
-  bool IsAnonymous = false;
-  bool IsLoadablyByAddress = isa<AllocStackInst>(SILVal);
-  IndirectionKind Indirection =
-      (IsLoadablyByAddress) ? DirectValue : IndirectValue;
-  VarInfo->Name = getVarName(i, IsAnonymous);
-  auto *Addr = getLoweredAddress(SILVal).getAddress();
-  SILType SILTy;
-  if (auto MaybeSILTy = VarInfo->Type)
-    // If there is auxiliary type info, use it
-    SILTy = *MaybeSILTy;
-  else
-    SILTy = SILVal->getType();
-  auto RealType = SILTy.getASTType();
-  if (CurSILFn->isAsync() && !i->getDebugScope()->InlinedCallSite) {
-    Indirection = CoroIndirectValue;
-    if (auto *PBI = dyn_cast<ProjectBoxInst>(i->getOperand())) {
-      // Usually debug info only ever describes the *result* of a projectBox
-      // call. To allow the debugger to display a boxed parameter of an async
-      // continuation object, however, the debug info can only describe the box
-      // itself and thus also needs to emit a box type for it so the debugger
-      // knows to call into Remote Mirrors to unbox the value.
-      RealType = PBI->getOperand()->getType().getASTType();
-      assert(isa<SILBoxType>(RealType));
-    }
-  }
-
-  DebugTypeInfo DbgTy;
-  if (VarDecl *Decl = i->getDecl())
-    DbgTy = DebugTypeInfo::getLocalVariable(Decl, RealType,
-                                            getTypeInfo(SILVal->getType()));
-  else if (i->getFunction()->isBare() && !SILTy.hasArchetype() &&
-           !VarInfo->Name.empty())
-    // Handle the cases that read from a SIL file
-    DbgTy = DebugTypeInfo::getFromTypeInfo(RealType, getTypeInfo(SILTy));
-  else
-    return;
-
-  bindArchetypes(DbgTy.getType());
-  if (!IGM.DebugInfo)
-    return;
-
-  // Put the value's address into a stack slot at -Onone and emit a debug
-  // intrinsic.
-  emitDebugVariableDeclaration(
-      emitShadowCopyIfNeeded(Addr, i->getDebugScope(), *VarInfo, IsAnonymous),
-      DbgTy, SILType(), i->getDebugScope(), i->getLoc(), *VarInfo, Indirection);
-}
-
 void IRGenSILFunction::visitFixLifetimeInst(swift::FixLifetimeInst *i) {
   if (i->getOperand()->getType().isAddress()) {
     // Just pass in the address to fix lifetime if we have one. We will not do

lib/IRGen/LoadableByAddress.cpp

@@ -1078,9 +1078,9 @@ static AllocStackInst *allocate(StructLoweringState &pass, SILType type) {
   // Insert an alloc_stack at the beginning of the function.
   SILBuilderWithScope allocBuilder(&*pass.F->begin());
   // Don't put any variable debug info into the alloc_stack, there will be a
-  // debug_value_addr insterted later. TODO: It may be more elegant to insert
+  // debug_value insterted later. TODO: It may be more elegant to insert
   // the variable info into the alloc_stack instead of additionally generating a
-  // debug_value_addr.
+  // debug_value.
   AllocStackInst *alloc = allocBuilder.createAllocStack(
       RegularLocation::getAutoGeneratedLocation(), type);
 
@@ -2969,10 +2969,8 @@ void LoadableByAddress::run() {
                 builtinInstrs.insert(instr);
                 break;
               }
-              case SILInstructionKind::DebugValueAddrInst:
-              case SILInstructionKind::DebugValueInst: {
+              case SILInstructionKind::DebugValueInst:
                 break;
-              }
               default:
                 llvm_unreachable("Unhandled use of FunctionRefInst");
               }

lib/SIL/IR/OperandOwnership.cpp

@@ -143,7 +143,6 @@ OPERAND_OWNERSHIP(TrivialUse, CondBranch)
 OPERAND_OWNERSHIP(TrivialUse, CondFail)
 OPERAND_OWNERSHIP(TrivialUse, CopyAddr)
 OPERAND_OWNERSHIP(TrivialUse, DeallocStack)
-OPERAND_OWNERSHIP(TrivialUse, DebugValueAddr)
 OPERAND_OWNERSHIP(TrivialUse, DeinitExistentialAddr)
 OPERAND_OWNERSHIP(TrivialUse, DestroyAddr)
 OPERAND_OWNERSHIP(TrivialUse, EndAccess)

lib/SIL/IR/SILDebugScope.cpp

@@ -60,5 +60,5 @@ SILFunction *SILDebugScope::getParentFunction() const {
 bool swift::maybeScopeless(const SILInstruction &inst) {
   if (inst.getFunction()->isBare())
     return true;
-  return !isa<DebugValueInst>(inst) && !isa<DebugValueAddrInst>(inst);
+  return !isa<DebugValueInst>(inst);
 }

lib/SIL/IR/SILInstruction.cpp

@@ -1367,7 +1367,6 @@ bool SILInstruction::isMetaInstruction() const {
   case SILInstructionKind::AllocBoxInst:
   case SILInstructionKind::AllocStackInst:
   case SILInstructionKind::DebugValueInst:
-  case SILInstructionKind::DebugValueAddrInst:
     return true;
   default:
     return false;

lib/SIL/IR/SILInstructions.cpp

@@ -380,33 +380,9 @@ bool DebugValueInst::exprStartsWithDeref() const {
           == SILDIExprOperator::Dereference;
 }
 
-DebugValueAddrInst::DebugValueAddrInst(SILDebugLocation DebugLoc,
-                                       SILValue Operand, SILDebugVariable Var)
-    : UnaryInstructionBase(DebugLoc, Operand),
-      SILDebugVariableSupplement(Var.DIExpr.getNumElements(),
-                                 Var.Type.hasValue(), Var.Loc.hasValue(),
-                                 Var.Scope),
-      VarInfo(Var, getTrailingObjects<char>(), getTrailingObjects<SILType>(),
-              getTrailingObjects<SILLocation>(),
-              getTrailingObjects<const SILDebugScope *>(),
-              getTrailingObjects<SILDIExprElement>()) {
-  if (auto *VD = DebugLoc.getLocation().getAsASTNode<VarDecl>())
-    VarInfo.setImplicit(VD->isImplicit() || VarInfo.isImplicit());
-}
-
-DebugValueAddrInst *DebugValueAddrInst::create(SILDebugLocation DebugLoc,
-                                               SILValue Operand, SILModule &M,
-                                               SILDebugVariable Var) {
-  void *buf = allocateDebugVarCarryingInst<DebugValueAddrInst>(M, Var);
-  return ::new (buf) DebugValueAddrInst(DebugLoc, Operand, Var);
-}
-
 VarDecl *DebugValueInst::getDecl() const {
   return getLoc().getAsASTNode<VarDecl>();
 }
-VarDecl *DebugValueAddrInst::getDecl() const {
-  return getLoc().getAsASTNode<VarDecl>();
-}
 
 AllocExistentialBoxInst *AllocExistentialBoxInst::create(
     SILDebugLocation Loc, SILType ExistentialType, CanType ConcreteType,