[DebugInfo] Support for DW_OP_implicit_pointer (llvm.dbg_derefval)

[alok]

Summary

  This patch (3/N) stems from D69787 as suggested by
  This is suggested by @jmorse.

  New intrinsic llvm.dbg.derefval is introduced.

Summary:
  Since dbg.value currently represents (VAR=VALUE), the new intrinsic dbg.derefval will represent de-referenced value (*VAR = VAL)
    - Below represents ptr=null
      call void @llvm.dbg.value(metadata i32* null, metadata !21, metadata !DIExpression())
    - And below represents *ptr=var
      call void @llvm.dbg.derefval(metadata !16, metadata !21, metadata !DIExpression(DW_OP_LLVM_implicit_pointer, DW_OP_LLVM_arg0, 0))
    - And below represents *ptr=arr[1]
      call void @llvm.dbg.derefval(metadata !16, metadata !21, metadata !DIExpression(DW_OP_LLVM_implicit_pointer, DW_OP_LLVM_arg0, 4))
    - We should be able to represent the case when a variable points to temporary (initialized by constant) and temporary is optimized out.
      tmp=[CONST]; ptr=&tmp;
      call void @llvm.dbg.derefval(metadata [CONST], metadata !21, metadata !DIExpression(DW_OP_LLVM_arg0))

[StephenTozer]

llvm/docs/SourceLevelDebugging.rst

270

Correct usefull -> useful

[jmorse]

Thanks for the patch, comments inline. A couple of things in general:

As mentioned on the mailing list thread, it bothers me a little that DbgVariableIntrinsic::getVariableLocation is going to try and return something that isn't a "Real" location. In fact, wouldn't the assertion at the end of getVariableLocation fire if the operand was a non-null non-ValueAsMetadata piece of metadata? It might make sense to add another level to the class hierarchy, to distinguish variable intrinsics that definitely always have a location, and the "more complicated" situation dbg.derefval has.

(I tried to think up what I'd like a class hierarchy to look like for all the debugging intrinsics, but they all have substantially different use cases).

I haven't reviewed the changes to SelectionDAG, I think those are probably better placed in D69886 with the other CodeGen changes, would you be able to move the changes into that review? (Both modify SelectionDAGBuilder.cpp). That way all the SelectionDAG modifications are in one place, and have the tests with them.

llvm/docs/SourceLevelDebugging.rst

261

I'd add some motivation to the first sentence, such as: "it it used to describe the dereferenced value of a pointer variable, when the pointer itself is no longer available in the program".

266–267

IMO "is" should read "must", i.e. "the first argument must be a local variable", to indicate this is required for correctness.

llvm/include/llvm/CodeGen/GlobalISel/MachineIRBuilder.h

369

"that the dereferenced"?

llvm/include/llvm/CodeGen/MachineInstrBuilder.h

227–236

Perhaps it's worth adding a new "add" method, i.e. "addImplicitPtrMetadata"? That avoids the extra argument, and in the call sites below it will be a little clearer what's happening, as a "true" argument isn't especially helpful.

Plus, then you can assert that only DILocalVariables (or whatever) are added as the implicit pointer metadata.

llvm/lib/CodeGen/LiveDebugValues.cpp

818–820

The main VarLoc constructor called on line 720 is going to not recognise the metadata operand and leave some fields uninitialized (it should probably actually assert in this case). I reckon you'll need to add a new location "Kind", and have it emitted in the BuildDbgValue method.

The LiveDebugValues algorithm should (TM) handle and propagate this kind of location fine.

llvm/lib/CodeGen/SelectionDAG/FastISel.cpp

1458

Perhaps easier here instead to have dbg_derefval and dbg_value share code, with an additional assertion that MetadataAsValue operands can only come from dbg_value's?

[alok]

llvm/docs/SourceLevelDebugging.rst

261

Thanks for comment. It will be incorporated in next version.

266–267

Thanks for your comment. It will be included in next version.

270

Thanks for your comment. It will be incorporated in next version.

llvm/include/llvm/CodeGen/GlobalISel/MachineIRBuilder.h

369

Thanks for your comment. It will be incorporated in next version.

llvm/include/llvm/CodeGen/MachineInstrBuilder.h

227–236

Thanks for your comment. It will be incorporated in next version.

llvm/lib/CodeGen/LiveDebugValues.cpp

818–820

Thanks for pointing this out. This will be incorporated in next version.

llvm/lib/CodeGen/SelectionDAG/FastISel.cpp

1458

Thanks for your comment. It will be incorporated in next version.

[alok]

This version is updated to rebase and to incorporate comments from @jmorse and @StephenTozer.

[alok]

Update to re-base and minor correction.

[alok]

Rebased and updated.

lldb/source/Expression/IRInterpreter.cpp

if (!called_function)
     return false;
 
   if (called_function->isIntrinsic()) {
     switch (called_function->getIntrinsicID()) {
     default:
       break;
     case llvm::Intrinsic::dbg_declare:
     case llvm::Intrinsic::dbg_value:
+    case llvm::Intrinsic::dbg_derefval:
       return true;
     }
   }
 
   return false;
 }
 
 class InterpreterStackFrame {

llvm/docs/SourceLevelDebugging.rst

 description of the variable.  The third argument is a `complex expression
 <LangRef.html#diexpression>`_.
 
 An `llvm.dbg.value` intrinsic describes the *value* of a source variable
 directly, not its address.  Note that the value operand of this intrinsic may
 be indirect (i.e, a pointer to the source variable), provided that interpreting
 the complex expression derives the direct value.
 
+``llvm.dbg.derefval``
+^^^^^^^^^^^^^^^^^^^^^
+
+.. code-block:: llvm
+
+  void @llvm.dbg.derefval(metadata, metadata, metadata)
+
+This intrinsic is identical to `llvm.dbg.value`, except that it is used to
+describe dereferenced value of a pointer variable, when the pointer itself is
+no longer available in the program.
+
+The first argument must be a `local variable <LangRef.html#dilocalvariable>`_.
+The second argument is a `local variable <LangRef.html#dilocalvariable>`_
+containing a description of the variable.  The third argument is a
+`complex expression <LangRef.html#diexpression>`_.
+
+An `llvm.dbg.derefval` intrinsic is useful when location which the variable
+points to is optimized out, but the dereferenced value is known.
+
+.. code-block:: text
+
+    call void @llvm.dbg.derefval(metadata !1, metadata !2,
+          metadata !DIExpression(DW_OP_LLVM_implicit_pointer,
+                                 DW_OP_LLVM_arg0, 0))
+    !1 = !DILocalVariable(name: "arr", ...) ; int arr[5]
+    !2 = !DILocalVariable(name: "ptr", ...) ; int *ptr; ptr=arr;
+    ...
+    call void @llvm.dbg.derefval(metadata i32 1, metadata !1,
+                         metadata !DIExpression(DW_OP_LLVM_arg0))
+    !1 = !DILocalVariable(name: "ptr", ...) ; int *ptr;tmp=1;ptr=&tmp;
+
 Object lifetimes and scoping
 ============================
 
 In many languages, the local variables in functions can have their lifetimes or
 scopes limited to a subset of a function.  In the C family of languages, for
 example, variables are only live (readable and writable) within the source
 block that they are defined in.  In functional languages, values are only
 readable after they have been defined.  Though this is a very obvious concept,

llvm/include/llvm/Analysis/TargetTransformInfoImpl.h

unsigned getIntrinsicCost(Intrinsic::ID IID, Type *RetTy,
     case Intrinsic::memcpy:
       return static_cast<T *>(this)->getMemcpyCost(dyn_cast<Instruction>(U));
 
     case Intrinsic::annotation:
     case Intrinsic::assume:
     case Intrinsic::sideeffect:
     case Intrinsic::dbg_declare:
     case Intrinsic::dbg_value:
+    case Intrinsic::dbg_derefval:
     case Intrinsic::dbg_label:
     case Intrinsic::invariant_start:
     case Intrinsic::invariant_end:
     case Intrinsic::launder_invariant_group:
     case Intrinsic::strip_invariant_group:
     case Intrinsic::is_constant:
     case Intrinsic::lifetime_start:
     case Intrinsic::lifetime_end:

llvm/include/llvm/CodeGen/GlobalISel/MachineIRBuilder.h

MachineInstrBuilder buildFIDbgValue(int FI, const MDNode *Variable,
                                       const MDNode *Expr);
 
   /// Build and insert a DBG_VALUE instructions specifying that \p Variable is
   /// given by \p C (suitably modified by \p Expr).
   MachineInstrBuilder buildConstDbgValue(const Constant &C,
                                          const MDNode *Variable,
                                          const MDNode *Expr);
 
+  /// Build and insert a DBG_VALUE instructions specifying that the dereferenced
+  /// value of \p Variable is given by \p V (suitably modified by \p Expr).
+  MachineInstrBuilder buildDerefDbgValue(const Value *V, const MDNode *Variable,
+                                         const MDNode *Expr);
+
   /// Build and insert a DBG_LABEL instructions specifying that \p Label is
   /// given. Convert "llvm.dbg.label Label" to "DBG_LABEL Label".
   MachineInstrBuilder buildDbgLabel(const MDNode *Label);
 
   /// Build and insert \p Res = G_DYN_STACKALLOC \p Size, \p Align
   ///
   /// G_DYN_STACKALLOC does a dynamic stack allocation and writes the address of
   /// the allocated memory into \p Res.

llvm/include/llvm/CodeGen/MachineInstr.h

public:
 
   /// Returns the debug location id of this MachineInstr.
   const DebugLoc &getDebugLoc() const { return debugLoc; }
 
   /// Return the debug variable referenced by
   /// this DBG_VALUE instruction.
   const DILocalVariable *getDebugVariable() const;
 
+  /// Return the debug implicit variable referenced by
+  /// this DBG_VALUE instruction.
+  const DIVariable *getDebugImplicitVariable() const;
+
   /// Return the complex address expression referenced by
   /// this DBG_VALUE instruction.
   const DIExpression *getDebugExpression() const;
 
   /// Return the debug label referenced by
   /// this DBG_LABEL instruction.
   const DILabel *getDebugLabel() const;
 

llvm/include/llvm/CodeGen/MachineInstrBuilder.h

public:
 
   const MachineInstrBuilder &add(ArrayRef<MachineOperand> MOs) const {
     for (const MachineOperand &MO : MOs) {
       MI->addOperand(*MF, MO);
     }
     return *this;
   }
 
   const MachineInstrBuilder &addMetadata(const MDNode *MD) const {
     MI->addOperand(*MF, MachineOperand::CreateMetadata(MD));
     assert((MI->isDebugValue() ? static_cast<bool>(MI->getDebugVariable())
                                : true) &&
            "first MDNode argument of a DBG_VALUE not a variable");
     assert((MI->isDebugLabel() ? static_cast<bool>(MI->getDebugLabel())
                                : true) &&
            "first MDNode argument of a DBG_LABEL not a label");
     return *this;
   }
 
+  const MachineInstrBuilder &addImplicitPtrMetadata(const MDNode *MD) const {
+    MI->addOperand(*MF, MachineOperand::CreateMetadata(MD));
+    assert(((MI->isDebugValue())
+                ? static_cast<bool>(MI->getDebugImplicitVariable())
+                : true) &&
+           "first MDNode argument of a DBG_VALUE not a DIVariable");
+    assert((MI->isDebugLabel() ? static_cast<bool>(MI->getDebugLabel())
+                               : true) &&
+           "first MDNode argument of a DBG_LABEL not a label");
+    return *this;
+  }
+
   const MachineInstrBuilder &addCFIIndex(unsigned CFIIndex) const {
     MI->addOperand(*MF, MachineOperand::CreateCFIIndex(CFIIndex));
     return *this;
   }
 
   const MachineInstrBuilder &addIntrinsicID(Intrinsic::ID ID) const {
     MI->addOperand(*MF, MachineOperand::CreateIntrinsicID(ID));
     return *this;

llvm/include/llvm/IR/DIBuilder.h

namespace llvm {
 
   class DIBuilder {
     Module &M;
     LLVMContext &VMContext;
 
     DICompileUnit *CUNode;   ///< The one compile unit created by this DIBuiler.
     Function *DeclareFn;     ///< llvm.dbg.declare
     Function *ValueFn;       ///< llvm.dbg.value
+    Function *DerefvalFn;    ///< llvm.dbg.derefval
     Function *LabelFn;       ///< llvm.dbg.label
 
     SmallVector<Metadata *, 4> AllEnumTypes;
     /// Track the RetainTypes, since they can be updated later on.
     SmallVector<TrackingMDNodeRef, 4> AllRetainTypes;
     SmallVector<Metadata *, 4> AllSubprograms;
     SmallVector<Metadata *, 4> AllGVs;
     SmallVector<TrackingMDNodeRef, 4> AllImportedModules;
Instruction *insertLabel(DILabel *LabelInfo, const DILocation *DL,
                              BasicBlock *InsertBB, Instruction *InsertBefore);
 
     /// Internal helper for insertDbgValueIntrinsic.
     Instruction *
     insertDbgValueIntrinsic(llvm::Value *Val, DILocalVariable *VarInfo,
                             DIExpression *Expr, const DILocation *DL,
                             BasicBlock *InsertBB, Instruction *InsertBefore);
 
+    /// Internal helper for insertDbgDerefValueIntrinsic.
+    Instruction *insertDbgDerefValueIntrinsic(
+        llvm::Value *Val, DILocalVariable *VarInfo, DIExpression *Expr,
+        const DILocation *DL, BasicBlock *InsertBB, Instruction *InsertBefore);
+
+    /// Internal helper for insertDbgDerefValueIntrinsic.
+    Instruction *insertDbgDerefValueIntrinsic(
+        DIVariable *Val, DILocalVariable *VarInfo, DIExpression *Expr,
+        const DILocation *DL, BasicBlock *InsertBB, Instruction *InsertBefore);
+
   public:
     /// Construct a builder for a module.
     ///
     /// If \c AllowUnresolved, collect unresolved nodes attached to the module
     /// in order to resolve cycles during \a finalize().
     ///
     /// If \p CU is given a value other than nullptr, then set \p CUNode to CU.
     explicit DIBuilder(Module &M, bool AllowUnresolved = true,
public:
     /// \param DL           Debug info location.
     /// \param InsertBefore Location for the new intrinsic.
     Instruction *insertDbgValueIntrinsic(llvm::Value *Val,
                                          DILocalVariable *VarInfo,
                                          DIExpression *Expr,
                                          const DILocation *DL,
                                          Instruction *InsertBefore);
 
+    /// Insert a new llvm.dbg.derefval intrinsic call.
+    /// \param Val          dereferenced value of the variable
+    /// \param VarInfo      Variable's debug info descriptor.
+    /// \param Expr         A complex location expression.
+    /// \param DL           Debug info location.
+    /// \param InsertBefore Location for the new intrinsic.
+    Instruction *insertDbgDerefValueIntrinsic(llvm::Value *Val,
+                                              DILocalVariable *VarInfo,
+                                              DIExpression *Expr,
+                                              const DILocation *DL,
+                                              Instruction *InsertBefore);
+
+    /// Insert a new llvm.dbg.derefval intrinsic call.
+    /// \param Val          dereferenced value of the variable
+    /// \param VarInfo      Variable's debug info descriptor.
+    /// \param Expr         A complex location expression.
+    /// \param DL           Debug info location.
+    /// \param InsertBefore Location for the new intrinsic.
+    Instruction *insertDbgDerefValueIntrinsic(DIVariable *Val,
+                                              DILocalVariable *VarInfo,
+                                              DIExpression *Expr,
+                                              const DILocation *DL,
+                                              Instruction *InsertBefore);
+
     /// Replace the vtable holder in the given type.
     ///
     /// If this creates a self reference, it may orphan some unresolved cycles
     /// in the operands of \c T, so \a DIBuilder needs to track that.
     void replaceVTableHolder(DICompositeType *&T,
                              DIType *VTableHolder);
 
     /// Replace arrays on a composite type.

llvm/include/llvm/IR/InstVisitor.h

#include "llvm/IR/Instruction.def"
   RetTy visitFuncletPadInst(FuncletPadInst &I) { DELEGATE(Instruction); }
   RetTy visitCleanupPadInst(CleanupPadInst &I) { DELEGATE(FuncletPadInst); }
   RetTy visitCatchPadInst(CatchPadInst &I)     { DELEGATE(FuncletPadInst); }
   RetTy visitFreezeInst(FreezeInst &I)         { DELEGATE(Instruction); }
 
   // Handle the special instrinsic instruction classes.
   RetTy visitDbgDeclareInst(DbgDeclareInst &I)    { DELEGATE(DbgVariableIntrinsic);}
   RetTy visitDbgValueInst(DbgValueInst &I)        { DELEGATE(DbgVariableIntrinsic);}
+  RetTy visitDbgDerefValueInst(DbgDerefValueInst &I) {
+    DELEGATE(DbgVariableIntrinsic);
+  }
   RetTy visitDbgVariableIntrinsic(DbgVariableIntrinsic &I)
                                                   { DELEGATE(DbgInfoIntrinsic);}
   RetTy visitDbgLabelInst(DbgLabelInst &I)        { DELEGATE(DbgInfoIntrinsic);}
   RetTy visitDbgInfoIntrinsic(DbgInfoIntrinsic &I){ DELEGATE(IntrinsicInst); }
   RetTy visitMemSetInst(MemSetInst &I)            { DELEGATE(MemIntrinsic); }
   RetTy visitMemCpyInst(MemCpyInst &I)            { DELEGATE(MemTransferInst); }
   RetTy visitMemMoveInst(MemMoveInst &I)          { DELEGATE(MemTransferInst); }
   RetTy visitMemTransferInst(MemTransferInst &I)  { DELEGATE(MemIntrinsic); }

 private:
   // Special helper function to delegate to CallInst subclass visitors.
   RetTy delegateCallInst(CallInst &I) {
     if (const Function *F = I.getCalledFunction()) {
       switch (F->getIntrinsicID()) {
       default:                     DELEGATE(IntrinsicInst);
       case Intrinsic::dbg_declare: DELEGATE(DbgDeclareInst);
       case Intrinsic::dbg_value:   DELEGATE(DbgValueInst);
+      case Intrinsic::dbg_derefval:
+        DELEGATE(DbgDerefValueInst);
       case Intrinsic::dbg_label:   DELEGATE(DbgLabelInst);
       case Intrinsic::memcpy:      DELEGATE(MemCpyInst);
       case Intrinsic::memmove:     DELEGATE(MemMoveInst);
       case Intrinsic::memset:      DELEGATE(MemSetInst);
       case Intrinsic::vastart:     DELEGATE(VAStartInst);
       case Intrinsic::vaend:       DELEGATE(VAEndInst);
       case Intrinsic::vacopy:      DELEGATE(VACopyInst);
       case Intrinsic::not_intrinsic: break;

llvm/include/llvm/IR/IntrinsicInst.h

namespace llvm {
   class DbgInfoIntrinsic : public IntrinsicInst {
   public:
     /// \name Casting methods
     /// @{
     static bool classof(const IntrinsicInst *I) {
       switch (I->getIntrinsicID()) {
       case Intrinsic::dbg_declare:
       case Intrinsic::dbg_value:
+      case Intrinsic::dbg_derefval:
       case Intrinsic::dbg_addr:
       case Intrinsic::dbg_label:
         return true;
       default: return false;
       }
     }
     static bool classof(const Value *V) {
       return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
     }
     /// @}
   };
 
   /// This is the common base class for debug info intrinsics for variables.
   class DbgVariableIntrinsic : public DbgInfoIntrinsic {
   public:
     /// Get the location corresponding to the variable referenced by the debug
     /// info intrinsic.  Depending on the intrinsic, this could be the
     /// variable's value or its address.
     Value *getVariableLocation(bool AllowNullOp = true) const;
 
+    Value *getDerefVariable(bool AllowNullOp = true) const;
+
     /// Does this describe the address of a local variable. True for dbg.addr
     /// and dbg.declare, but not dbg.value, which describes its value.
     bool isAddressOfVariable() const {
-      return getIntrinsicID() != Intrinsic::dbg_value;
+      return getIntrinsicID() == Intrinsic::dbg_declare ||
+             getIntrinsicID() == Intrinsic::dbg_addr;
     }
 
     DILocalVariable *getVariable() const {
       return cast<DILocalVariable>(getRawVariable());
     }
 
     DIExpression *getExpression() const {
       return cast<DIExpression>(getRawExpression());
public:
     Optional<uint64_t> getFragmentSizeInBits() const;
 
     /// \name Casting methods
     /// @{
     static bool classof(const IntrinsicInst *I) {
       switch (I->getIntrinsicID()) {
       case Intrinsic::dbg_declare:
       case Intrinsic::dbg_value:
+      case Intrinsic::dbg_derefval:
       case Intrinsic::dbg_addr:
         return true;
       default: return false;
       }
     }
     static bool classof(const Value *V) {
       return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
     }
static bool classof(const IntrinsicInst *I) {
       return I->getIntrinsicID() == Intrinsic::dbg_value;
     }
     static bool classof(const Value *V) {
       return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
     }
     /// @}
   };
 
+  /// This represents the llvm.dbg.deref.value instruction.
+  class DbgDerefValueInst : public DbgVariableIntrinsic {
+  public:
+    Value *getValue() const {
+      return getDerefVariable(/* AllowNullOp = */ false);
+    }
+
+    /// \name Casting methods
+    /// @{
+    static bool classof(const IntrinsicInst *I) {
+      return I->getIntrinsicID() == Intrinsic::dbg_derefval;
+    }
+    static bool classof(const Value *V) {
+      return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
+    }
+    /// @}
+  };
+
   /// This represents the llvm.dbg.label instruction.
   class DbgLabelInst : public DbgInfoIntrinsic {
   public:
     DILabel *getLabel() const {
       return cast<DILabel>(getRawLabel());
     }
 
     Metadata *getRawLabel() const {

llvm/include/llvm/IR/Intrinsics.td

let IntrProperties = [IntrNoMem, IntrSpeculatable, IntrWillReturn] in {
   def int_dbg_declare      : Intrinsic<[],
                                        [llvm_metadata_ty,
                                         llvm_metadata_ty,
                                         llvm_metadata_ty]>;
   def int_dbg_value        : Intrinsic<[],
                                        [llvm_metadata_ty,
                                         llvm_metadata_ty,
                                         llvm_metadata_ty]>;
+  def int_dbg_derefval     : Intrinsic<[],
+                                       [llvm_metadata_ty,
+                                        llvm_metadata_ty,
+                                        llvm_metadata_ty]>;
   def int_dbg_addr         : Intrinsic<[],
                                        [llvm_metadata_ty,
                                         llvm_metadata_ty,
                                         llvm_metadata_ty]>;
   def int_dbg_label        : Intrinsic<[],
                                        [llvm_metadata_ty]>;
 }
 

llvm/lib/Analysis/MemorySSA.cpp

if (const IntrinsicInst *II = dyn_cast<IntrinsicInst>(DefInst)) {
     case Intrinsic::invariant_start:
     case Intrinsic::invariant_end:
     case Intrinsic::assume:
       return {false, NoAlias};
     case Intrinsic::dbg_addr:
     case Intrinsic::dbg_declare:
     case Intrinsic::dbg_label:
     case Intrinsic::dbg_value:
+    case Intrinsic::dbg_derefval:
       llvm_unreachable("debuginfo shouldn't have associated defs!");
     default:
       break;
     }
   }
 
   if (UseCall) {
     ModRefInfo I = AA.getModRefInfo(DefInst, UseCall);

llvm/lib/Analysis/ObjCARCInstKind.cpp

static bool isInertIntrinsic(unsigned ID) {
   case Intrinsic::adjust_trampoline:
   case Intrinsic::lifetime_start:
   case Intrinsic::lifetime_end:
   case Intrinsic::invariant_start:
   case Intrinsic::invariant_end:
   // Don't let dbg info affect our results.
   case Intrinsic::dbg_declare:
   case Intrinsic::dbg_value:
+  case Intrinsic::dbg_derefval:
   case Intrinsic::dbg_label:
     // Short cut: Some intrinsics obviously don't use ObjC pointers.
     return true;
   default:
     return false;
   }
 }
 

llvm/lib/Analysis/ValueTracking.cpp

if (const CallInst *CI = dyn_cast<CallInst>(I))
     if (Function *F = CI->getCalledFunction())
       switch (F->getIntrinsicID()) {
       default: break;
       // FIXME: This list is repeated from NoTTI::getIntrinsicCost.
       case Intrinsic::assume:
       case Intrinsic::sideeffect:
       case Intrinsic::dbg_declare:
       case Intrinsic::dbg_value:
+      case Intrinsic::dbg_derefval:
       case Intrinsic::dbg_label:
       case Intrinsic::invariant_start:
       case Intrinsic::invariant_end:
       case Intrinsic::lifetime_start:
       case Intrinsic::lifetime_end:
       case Intrinsic::objectsize:
       case Intrinsic::ptr_annotation:
       case Intrinsic::var_annotation:

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

static bool emitDebugValueComment(const MachineInstr *MI, AsmPrinter &AP) {
   } else if (MI->getOperand(0).isImm()) {
     OS << MI->getOperand(0).getImm();
   } else if (MI->getOperand(0).isCImm()) {
     MI->getOperand(0).getCImm()->getValue().print(OS, false /*isSigned*/);
   } else if (MI->getOperand(0).isTargetIndex()) {
     auto Op = MI->getOperand(0);
     OS << "!target-index(" << Op.getIndex() << "," << Op.getOffset() << ")";
     return true;
+  } else if (MI->getOperand(0).isMetadata()) {
+    OS << MI->getOperand(0).getMetadata();
   } else {
     unsigned Reg;
     if (MI->getOperand(0).isReg()) {
       Reg = MI->getOperand(0).getReg();
     } else {
       assert(MI->getOperand(0).isFI() && "Unknown operand type");
       const TargetFrameLowering *TFI = AP.MF->getSubtarget().getFrameLowering();
       Offset += TFI->getFrameIndexReference(*AP.MF,

llvm/lib/CodeGen/GlobalISel/IRTranslator.cpp

if (!V) {
         // direct/indirect thing shouldn't really be handled by something as
         // implicit as reg+noreg vs reg+imm in the first place, but it seems
         // pretty baked in right now.
         MIRBuilder.buildDirectDbgValue(Reg, DI.getVariable(), DI.getExpression());
       }
     }
     return true;
   }
+  case Intrinsic::dbg_derefval: {
+    // This form of DBG_VALUE is target-independent.
+    const DbgDerefValueInst &DI = cast<DbgDerefValueInst>(CI);
+    const Value *V = DI.getValue();
+    assert(DI.getVariable()->isValidLocationForIntrinsic(
+               MIRBuilder.getDebugLoc()) &&
+           "Expected inlined-at fields to agree");
+    if (!V) {
+      // Currently the optimizer can produce this; insert an undef to
+      // help debugging.  Probably the optimizer should not do this.
+      MIRBuilder.buildDirectDbgValue(0, DI.getVariable(), DI.getExpression());
+    } else {
+      MIRBuilder.buildDerefDbgValue(V, DI.getVariable(), DI.getExpression());
+    }
+    return true;
+  }
   case Intrinsic::uadd_with_overflow:
     return translateOverflowIntrinsic(CI, TargetOpcode::G_UADDO, MIRBuilder);
   case Intrinsic::sadd_with_overflow:
     return translateOverflowIntrinsic(CI, TargetOpcode::G_SADDO, MIRBuilder);
   case Intrinsic::usub_with_overflow:
     return translateOverflowIntrinsic(CI, TargetOpcode::G_USUBO, MIRBuilder);
   case Intrinsic::ssub_with_overflow:
     return translateOverflowIntrinsic(CI, TargetOpcode::G_SSUBO, MIRBuilder);

llvm/lib/CodeGen/GlobalISel/MachineIRBuilder.cpp

MachineInstrBuilder MachineIRBuilder::buildConstDbgValue(const Constant &C,
   } else {
     // Insert %noreg if we didn't find a usable constant and had to drop it.
     MIB.addReg(0U);
   }
 
   return MIB.addReg(0).addMetadata(Variable).addMetadata(Expr);
 }
 
+MachineInstrBuilder MachineIRBuilder::buildDerefDbgValue(const Value *Derefval,
+                                                         const MDNode *Variable,
+                                                         const MDNode *Expr) {
+  assert(isa<DILocalVariable>(Variable) && "not a variable");
+  assert(cast<DIExpression>(Expr)->isValid() && "not an expression");
+  assert(
+      cast<DILocalVariable>(Variable)->isValidLocationForIntrinsic(getDL()) &&
+      "Expected inlined-at fields to agree");
+  auto MIB = buildInstr(TargetOpcode::DBG_VALUE);
+  if (const auto *MDV = dyn_cast<llvm::MetadataAsValue>(Derefval)) {
+    if (const auto *LDV = dyn_cast<llvm::DIVariable>(MDV->getMetadata())) {
+      MIB.addImplicitPtrMetadata(LDV);
+    }
+  } else if (auto *CI = dyn_cast<ConstantInt>(Derefval)) {
+    if (CI->getBitWidth() > 64)
+      MIB.addCImm(CI);
+    else
+      MIB.addImm(CI->getZExtValue());
+  } else if (auto *CFP = dyn_cast<ConstantFP>(Derefval)) {
+    MIB.addFPImm(CFP);
+  } else {
+    // Insert %noreg if we didn't find a usable constant and had to drop it.
+    MIB.addReg(0U);
+  }
+
+  return MIB.addReg(0).addMetadata(Variable).addMetadata(Expr);
+}
+
 MachineInstrBuilder MachineIRBuilder::buildDbgLabel(const MDNode *Label) {
   assert(isa<DILabel>(Label) && "not a label");
   assert(cast<DILabel>(Label)->isValidLocationForIntrinsic(State.DL) &&
          "Expected inlined-at fields to agree");
   auto MIB = buildInstr(TargetOpcode::DBG_LABEL);
 
   return MIB.addMetadata(Label);
 }

llvm/lib/CodeGen/LiveDebugValues.cpp

struct VarLoc {
     mutable UserValueScopes UVS;
     enum VarLocKind {
       InvalidKind = 0,
       RegisterKind,
       SpillLocKind,
       ImmediateKind,
       EntryValueKind,
       EntryValueBackupKind,
-      EntryValueCopyBackupKind
+      EntryValueCopyBackupKind,
+      ImplicitPtrKind
     } Kind = InvalidKind;
 
     /// The value location. Stored separately to avoid repeatedly
     /// extracting it from MI.
     union {
       uint64_t RegNo;
       SpillLoc SpillLocation;
       uint64_t Hash;
       int64_t Immediate;
       const ConstantFP *FPImm;
       const ConstantInt *CImm;
+      const DIVariable *ImplicitPtr;
     } Loc;
 
     VarLoc(const MachineInstr &MI, LexicalScopes &LS)
         : Var(MI.getDebugVariable(), MI.getDebugExpression(),
               MI.getDebugLoc()->getInlinedAt()),
           Expr(MI.getDebugExpression()), MI(MI), UVS(MI.getDebugLoc(), LS) {
       static_assert((sizeof(Loc) == sizeof(uint64_t)),
                     "hash does not cover all members of Loc");
       assert(MI.isDebugValue() && "not a DBG_VALUE");
       assert(MI.getNumOperands() == 4 && "malformed DBG_VALUE");
       if (int RegNo = isDbgValueDescribedByReg(MI)) {
         Kind = RegisterKind;
         Loc.RegNo = RegNo;
       } else if (MI.getOperand(0).isImm()) {
         Kind = ImmediateKind;
         Loc.Immediate = MI.getOperand(0).getImm();
       } else if (MI.getOperand(0).isFPImm()) {
         Kind = ImmediateKind;
         Loc.FPImm = MI.getOperand(0).getFPImm();
       } else if (MI.getOperand(0).isCImm()) {
         Kind = ImmediateKind;
         Loc.CImm = MI.getOperand(0).getCImm();
+      } else if (MI.getOperand(0).isMetadata()) {
+        Kind = ImplicitPtrKind;
+        Loc.ImplicitPtr = MI.getDebugImplicitVariable();
       }
 
       // We create the debug entry values from the factory functions rather than
       // from this ctor.
       assert(Kind != EntryValueKind && !isEntryBackupLoc());
     }
 
     /// Take the variable and machine-location in DBG_VALUE MI, and build an
MachineInstr *BuildDbgValue(MachineFunction &MF) const {
             DIExpr, DIExpression::ApplyOffset, Loc.SpillLocation.SpillOffset);
         unsigned Base = Loc.SpillLocation.SpillBase;
         return BuildMI(MF, DbgLoc, IID, true, Base, Var, SpillExpr);
       }
       case ImmediateKind: {
         MachineOperand MO = MI.getOperand(0);
         return BuildMI(MF, DbgLoc, IID, Indirect, MO, Var, DIExpr);
       }
+      case ImplicitPtrKind: {
+        MachineOperand MO = MI.getOperand(0);
+        return BuildMI(MF, DbgLoc, IID, Indirect, MO, Var, DIExpr);
+      }
       case EntryValueBackupKind:
       case EntryValueCopyBackupKind:
       case InvalidKind:
         llvm_unreachable(
             "Tried to produce DBG_VALUE for invalid or backup VarLoc");
       }
       llvm_unreachable("Unrecognized LiveDebugValues.VarLoc.Kind enum");
     }
void dump(const TargetRegisterInfo *TRI, raw_ostream &Out = dbgs()) const {
         break;
       case SpillLocKind:
         dbgs() << printReg(Loc.SpillLocation.SpillBase, TRI);
         dbgs() << "[" << Loc.SpillLocation.SpillOffset << "]";
         break;
       case ImmediateKind:
         dbgs() << Loc.Immediate;
         break;
+      case ImplicitPtrKind:
+        dbgs() << Loc.ImplicitPtr->getName();
+        break;
       case InvalidKind:
         llvm_unreachable("Invalid VarLoc in dump method");
       }
 
       dbgs() << ", \"" << Var.getVariable()->getName() << "\", " << *Expr
              << ", ";
       if (Var.getInlinedAt())
         dbgs() << "!" << Var.getInlinedAt()->getMetadataID() << ")\n";
if (removeEntryValue(MI, OpenRanges, VarLocIDs, EntryVL)) {
                           /*SkipOpers*/ false, /*SkipDebugLoc*/ false,
                           /*AddNewLine*/ true, TII));
       OpenRanges.erase(EntryVL);
     }
   }
 
   unsigned ID;
   if (isDbgValueDescribedByReg(MI) || MI.getOperand(0).isImm() ||
-      MI.getOperand(0).isFPImm() || MI.getOperand(0).isCImm()) {
+      MI.getOperand(0).isFPImm() || MI.getOperand(0).isCImm() ||
+      MI.getOperand(0).isMetadata()) {
     // Use normal VarLoc constructor for registers and immediates.
     VarLoc VL(MI, LS);
     // End all previous ranges of VL.Var.
     OpenRanges.erase(VL);
 
     ID = VarLocIDs.insert(VL);
     // Add the VarLoc to OpenRanges from this DBG_VALUE.
     OpenRanges.insert(ID, VL);
   } else if (MI.hasOneMemOperand()) {

llvm/lib/CodeGen/MachineInstr.cpp

const DILabel *MachineInstr::getDebugLabel() const {
   return cast<DILabel>(getOperand(0).getMetadata());
 }
 
 const DILocalVariable *MachineInstr::getDebugVariable() const {
   assert(isDebugValue() && "not a DBG_VALUE");
   return cast<DILocalVariable>(getOperand(2).getMetadata());
 }
 
+const DIVariable *MachineInstr::getDebugImplicitVariable() const {
+  assert(isDebugValue() && "not a DBG_VALUE");
+  return cast<DIVariable>(getOperand(0).getMetadata());
+}
+
 const DIExpression *MachineInstr::getDebugExpression() const {
   assert(isDebugValue() && "not a DBG_VALUE");
   return cast<DIExpression>(getOperand(3).getMetadata());
 }
 
 bool MachineInstr::isDebugEntryValue() const {
   return isDebugValue() && getDebugExpression()->isEntryValue();
 }

llvm/lib/CodeGen/SelectionDAG/FastISel.cpp

if (Op) {
               *Op, DI->getVariable(), Expr);
     } else {
       // We can't yet handle anything else here because it would require
       // generating code, thus altering codegen because of debug info.
       LLVM_DEBUG(dbgs() << "Dropping debug info for " << *DI << "\n");
     }
     return true;
   }
-  case Intrinsic::dbg_value: {
+  case Intrinsic::dbg_value:
+  case Intrinsic::dbg_derefval: {
     // This form of DBG_VALUE is target-independent.
-    const DbgValueInst *DI = cast<DbgValueInst>(II);
+    const DbgVariableIntrinsic *DI = cast<DbgVariableIntrinsic>(II);
     const MCInstrDesc &II = TII.get(TargetOpcode::DBG_VALUE);
-    const Value *V = DI->getValue();
+    const Value *V = DbgValueInst::classof(DI) ? DI->getVariableLocation(false)
+                                               : DI->getDerefVariable(false);
     assert(DI->getVariable()->isValidLocationForIntrinsic(DbgLoc) &&
            "Expected inlined-at fields to agree");
     if (!V) {
       // Currently the optimizer can produce this; insert an undef to
       // help debugging.  Probably the optimizer should not do this.
       BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, II, false, 0U,
               DI->getVariable(), DI->getExpression());
     } else if (const auto *CI = dyn_cast<ConstantInt>(V)) {
if (!V) {
           .addReg(0U)
           .addMetadata(DI->getVariable())
           .addMetadata(DI->getExpression());
     } else if (unsigned Reg = lookUpRegForValue(V)) {
       // FIXME: This does not handle register-indirect values at offset 0.
       bool IsIndirect = false;
       BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, II, IsIndirect, Reg,
               DI->getVariable(), DI->getExpression());
+    } else if (DbgDerefValueInst::classof(DI)) {
+      if (const auto *MDV = dyn_cast<llvm::MetadataAsValue>(V))
+        if (const auto *LDV = dyn_cast<llvm::DIVariable>(MDV->getMetadata())) {
+          BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, II)
+              .addImplicitPtrMetadata(LDV)
+              .addReg(0U)
+              .addMetadata(DI->getVariable())
+              .addMetadata(DI->getExpression());
+      }
     } else {
       // We can't yet handle anything else here because it would require
       // generating code, thus altering codegen because of debug info.
       LLVM_DEBUG(dbgs() << "Dropping debug info for " << *DI << "\n");
     }
     return true;
   }
   case Intrinsic::dbg_label: {
     const DbgLabelInst *DI = cast<DbgLabelInst>(II);
     assert(DI->getLabel() && "Missing label");
     if (!FuncInfo.MF->getMMI().hasDebugInfo()) {
       LLVM_DEBUG(dbgs() << "Dropping debug info for " << *DI << "\n");
       return true;
     }
 
     BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc,

llvm/lib/IR/DIBuilder.cpp

 
 static cl::opt<bool>
     UseDbgAddr("use-dbg-addr",
                llvm::cl::desc("Use llvm.dbg.addr for all local variables"),
                cl::init(false), cl::Hidden);
 
 DIBuilder::DIBuilder(Module &m, bool AllowUnresolvedNodes, DICompileUnit *CU)
   : M(m), VMContext(M.getContext()), CUNode(CU),
-      DeclareFn(nullptr), ValueFn(nullptr), LabelFn(nullptr),
+      DeclareFn(nullptr), ValueFn(nullptr), DerefvalFn(nullptr), LabelFn(nullptr),
       AllowUnresolvedNodes(AllowUnresolvedNodes) {}
 
 void DIBuilder::trackIfUnresolved(MDNode *N) {
   if (!N)
     return;
   if (N->isResolved())
     return;
 
Instruction *DIBuilder::insertDbgValueIntrinsic(Value *V,
                                                 DIExpression *Expr,
                                                 const DILocation *DL,
                                                 Instruction *InsertBefore) {
   return insertDbgValueIntrinsic(
       V, VarInfo, Expr, DL, InsertBefore ? InsertBefore->getParent() : nullptr,
       InsertBefore);
 }
 
+Instruction *DIBuilder::insertDbgDerefValueIntrinsic(
+    Value *V, DILocalVariable *VarInfo, DIExpression *Expr,
+    const DILocation *DL, Instruction *InsertBefore) {
+  return insertDbgDerefValueIntrinsic(
+      V, VarInfo, Expr, DL, InsertBefore ? InsertBefore->getParent() : nullptr,
+      InsertBefore);
+}
+
+Instruction *DIBuilder::insertDbgDerefValueIntrinsic(
+    DIVariable *V, DILocalVariable *VarInfo, DIExpression *Expr,
+    const DILocation *DL, Instruction *InsertBefore) {
+  return insertDbgDerefValueIntrinsic(
+      V, VarInfo, Expr, DL, InsertBefore ? InsertBefore->getParent() : nullptr,
+      InsertBefore);
+}
+
 Instruction *DIBuilder::insertDbgValueIntrinsic(Value *V,
                                                 DILocalVariable *VarInfo,
                                                 DIExpression *Expr,
                                                 const DILocation *DL,
                                                 BasicBlock *InsertAtEnd) {
   return insertDbgValueIntrinsic(V, VarInfo, Expr, DL, InsertAtEnd, nullptr);
 }
 
Instruction *DIBuilder::insertDbgValueIntrinsic(
   Value *Args[] = {getDbgIntrinsicValueImpl(VMContext, V),
                    MetadataAsValue::get(VMContext, VarInfo),
                    MetadataAsValue::get(VMContext, Expr)};
 
   IRBuilder<> B = getIRBForDbgInsertion(DL, InsertBB, InsertBefore);
   return B.CreateCall(ValueFn, Args);
 }
 
+Instruction *DIBuilder::insertDbgDerefValueIntrinsic(
+    Value *V, DILocalVariable *VarInfo, DIExpression *Expr,
+    const DILocation *DL, BasicBlock *InsertBB, Instruction *InsertBefore) {
+  assert(V && "no value passed to dbg.derefval");
+  assert(VarInfo && "empty or invalid DILocalVariable* passed to dbg.derefval");
+  assert(DL && "Expected debug loc");
+  assert(DL->getScope()->getSubprogram() ==
+             VarInfo->getScope()->getSubprogram() &&
+         "Expected matching subprograms");
+  if (!DerefvalFn)
+    DerefvalFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_derefval);
+
+  trackIfUnresolved(VarInfo);
+  trackIfUnresolved(Expr);
+  Value *Args[] = {V, MetadataAsValue::get(VMContext, VarInfo),
+                   MetadataAsValue::get(VMContext, Expr)};
+
+  IRBuilder<> B = getIRBForDbgInsertion(DL, InsertBB, InsertBefore);
+  return B.CreateCall(DerefvalFn, Args);
+}
+
+Instruction *DIBuilder::insertDbgDerefValueIntrinsic(
+    DIVariable *V, DILocalVariable *VarInfo, DIExpression *Expr,
+    const DILocation *DL, BasicBlock *InsertBB, Instruction *InsertBefore) {
+  assert(V && "no value passed to dbg.derefval");
+  assert(VarInfo && "empty or invalid DILocalVariable* passed to dbg.derefval");
+  assert(DL && "Expected debug loc");
+  assert(DL->getScope()->getSubprogram() ==
+             VarInfo->getScope()->getSubprogram() &&
+         "Expected matching subprograms");
+  if (!DerefvalFn)
+    DerefvalFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_derefval);
+
+  trackIfUnresolved(VarInfo);
+  trackIfUnresolved(Expr);
+  Value *Args[] = {MetadataAsValue::get(VMContext, V), MetadataAsValue::get(VMContext, VarInfo),
+                   MetadataAsValue::get(VMContext, Expr)};
+
+  IRBuilder<> B = getIRBForDbgInsertion(DL, InsertBB, InsertBefore);
+  return B.CreateCall(DerefvalFn, Args);
+}
+
 Instruction *DIBuilder::insertLabel(
     DILabel *LabelInfo, const DILocation *DL,
     BasicBlock *InsertBB, Instruction *InsertBefore) {
   assert(LabelInfo && "empty or invalid DILabel* passed to dbg.label");
   assert(DL && "Expected debug loc");
   assert(DL->getScope()->getSubprogram() ==
              LabelInfo->getScope()->getSubprogram() &&
          "Expected matching subprograms");

llvm/lib/IR/IntrinsicInst.cpp

Value *DbgVariableIntrinsic::getVariableLocation(bool AllowNullOp) const {
   if (auto *V = dyn_cast<ValueAsMetadata>(MD))
     return V->getValue();
 
   // When the value goes to null, it gets replaced by an empty MDNode.
   assert(!cast<MDNode>(MD)->getNumOperands() && "Expected an empty MDNode");
   return nullptr;
 }
 
+Value *DbgVariableIntrinsic::getDerefVariable(bool AllowNullOp) const {
+  Value *Op = getArgOperand(0);
+  if (AllowNullOp && !Op)
+    return nullptr;
+
+  return Op;
+}
+
 Optional<uint64_t> DbgVariableIntrinsic::getFragmentSizeInBits() const {
   if (auto Fragment = getExpression()->getFragmentInfo())
     return Fragment->SizeInBits;
   return getVariable()->getSizeInBits();
 }
 
 int llvm::Intrinsic::lookupLLVMIntrinsicByName(ArrayRef<const char *> NameTable,
                                                StringRef Name) {

llvm/lib/IR/Verifier.cpp

case Intrinsic::dbg_declare: // llvm.dbg.declare
     visitDbgIntrinsic("declare", cast<DbgVariableIntrinsic>(Call));
     break;
   case Intrinsic::dbg_addr: // llvm.dbg.addr
     visitDbgIntrinsic("addr", cast<DbgVariableIntrinsic>(Call));
     break;
   case Intrinsic::dbg_value: // llvm.dbg.value
     visitDbgIntrinsic("value", cast<DbgVariableIntrinsic>(Call));
     break;
+  case Intrinsic::dbg_derefval: // llvm.dbg.derefval
+    visitDbgIntrinsic("derefval", cast<DbgVariableIntrinsic>(Call));
+    break;
   case Intrinsic::dbg_label: // llvm.dbg.label
     visitDbgLabelIntrinsic("label", cast<DbgLabelInst>(Call));
     break;
   case Intrinsic::memcpy:
   case Intrinsic::memmove:
   case Intrinsic::memset: {
     const auto *MI = cast<MemIntrinsic>(&Call);
     auto IsValidAlignment = [&](unsigned Alignment) -> bool {
if (HasRoundingMD) {
     Assert(FPI.getRoundingMode().hasValue(),
            "invalid rounding mode argument", &FPI);
   }
 }
 
 void Verifier::visitDbgIntrinsic(StringRef Kind, DbgVariableIntrinsic &DII) {
   auto *MD = cast<MetadataAsValue>(DII.getArgOperand(0))->getMetadata();
   AssertDI(isa<ValueAsMetadata>(MD) ||
-             (isa<MDNode>(MD) && !cast<MDNode>(MD)->getNumOperands()),
+               (isa<MDNode>(MD) && !cast<MDNode>(MD)->getNumOperands()) ||
+               isa<DbgDerefValueInst>(DII),
            "invalid llvm.dbg." + Kind + " intrinsic address/value", &DII, MD);
   AssertDI(isa<DILocalVariable>(DII.getRawVariable()),
          "invalid llvm.dbg." + Kind + " intrinsic variable", &DII,
          DII.getRawVariable());
   AssertDI(isa<DIExpression>(DII.getRawExpression()),
          "invalid llvm.dbg." + Kind + " intrinsic expression", &DII,
          DII.getRawExpression());
 
   // Ignore broken !dbg attachments; they're checked elsewhere.

llvm/lib/Transforms/Utils/Local.cpp

if (DDI->getAddress())
       return false;
     return true;
   }
   if (DbgValueInst *DVI = dyn_cast<DbgValueInst>(I)) {
     if (DVI->getValue())
       return false;
     return true;
   }
+  if (DbgDerefValueInst *DVI = dyn_cast<DbgDerefValueInst>(I)) {
+    if (DVI->getDerefVariable())
+      return false;
+    return true;
+  }
   if (DbgLabelInst *DLI = dyn_cast<DbgLabelInst>(I)) {
     if (DLI->getLabel())
       return false;
     return true;
   }
 
   if (!I->mayHaveSideEffects())
     return true;

llvm/lib/Transforms/Utils/SimplifyCFG.cpp

while (++I != E) {
     auto *II = dyn_cast<IntrinsicInst>(I);
     if (!II)
       return false;
 
     Intrinsic::ID IntrinsicID = II->getIntrinsicID();
     switch (IntrinsicID) {
     case Intrinsic::dbg_declare:
     case Intrinsic::dbg_value:
+    case Intrinsic::dbg_derefval:
     case Intrinsic::dbg_label:
     case Intrinsic::lifetime_end:
       break;
     default:
       return false;
     }
   }
 

polly/lib/Support/ScopHelper.cpp

if (auto *IT = dyn_cast<IntrinsicInst>(V)) {
     // Some misc annotations are supported/ignored.
     case llvm::Intrinsic::var_annotation:
     case llvm::Intrinsic::ptr_annotation:
     case llvm::Intrinsic::annotation:
     case llvm::Intrinsic::donothing:
     case llvm::Intrinsic::assume:
     // Some debug info intrinsics are supported/ignored.
     case llvm::Intrinsic::dbg_value:
+    case llvm::Intrinsic::dbg_derefval:
     case llvm::Intrinsic::dbg_declare:
       return true;
     default:
       break;
     }
   }
   return false;
 }