[DebugInfo] Support for DW_OP_LLVM_explicit_pointer (temp2reg).

[alok]

Summary

Summary:

This enables debugger to display de-referenced value of pointer in case temporary is optimized out. It happens in case of reference. This patch need to include some compile time option to enable/disable.

Testing:

-Added unit test for validation thru llvm-dwarfdump
-check-llvm (LLDB need to be modifed to support this)
-check-debuginfo (the debug info integration tests)

[alok]

Updated to rename proposed LLVM Dwarf extension to DW_OP_LLVM_explicit_pointer.

[dblaikie]

llvm/docs/LangRef.rst

4828–4829

I think this probably still needs some design discussion on the llvm-dev design thread (I know I'm mostly slacking there) - specifically the "can only appear at the beginning" seems like it misses the case I brought up on the thread about multiple levels of indirection.

llvm/docs/LangRef.rst

- ``DW_OP_LLVM_argN`` represents argument number N of the containing LLVM
   ``call @llvm.dbg.someintrinsic(DILocalVariable("x"), DILocalVariable("y"),
   metadata !DIExpression(DW_OP_LLVM_arg0, DW_OP_LLVM_arg1, DW_OP_plus))``
   ``DW_OP_LLVM_arg0`` represents ``DILocalVariable("x")`` and
   ``DW_OP_LLVM_arg1`` represents ``DILocalVariable("y")``.
 - ``DW_OP_LLVM_implicit_pointer, DW_OP_LLVM_arg0 N`` can only appear at the
   beginning of a ``DIExpression``, and it specifies the value of variable
   represented by the ``DILocalVariable`` referred to by the instructions 
   value/address operand at offset N.
+- ``DW_OP_LLVM_explicit_pointer`` can only appear at the beginning of a
+  ``DIExpression``, and it specifies the dereferenced value.
 
 DWARF specifies three kinds of simple location descriptions: Register, memory,
 and implicit location descriptions.  Note that a location description is
 defined over certain ranges of a program, i.e the location of a variable may
 change over the course of the program. Register and memory location
 descriptions describe the *concrete location* of a source variable (in the
 sense that a debugger might modify its value), whereas *implicit locations*
 describe merely the actual *value* of a source variable which might not exist

llvm/include/llvm/BinaryFormat/Dwarf.def

 HANDLE_DW_OP(0xa3, entry_value, 5, DWARF)
 HANDLE_DW_OP(0xa4, const_type, 5, DWARF)
 HANDLE_DW_OP(0xa5, regval_type, 5, DWARF)
 HANDLE_DW_OP(0xa6, deref_type, 5, DWARF)
 HANDLE_DW_OP(0xa7, xderef_type, 5, DWARF)
 HANDLE_DW_OP(0xa8, convert, 5, DWARF)
 HANDLE_DW_OP(0xa9, reinterpret, 5, DWARF)
 // Vendor extensions:
+// Extensions for LLVM explicit_pointer
+HANDLE_DW_OP(0xd0, LLVM_explicit_pointer, 5, LLVM)
 // Extensions for GNU-style thread-local storage.
 HANDLE_DW_OP(0xe0, GNU_push_tls_address, 0, GNU)
 // The GNU entry value extension.
 HANDLE_DW_OP(0xf3, GNU_entry_value, 0, GNU)
 // Extensions for Fission proposal.
 HANDLE_DW_OP(0xfb, GNU_addr_index, 0, GNU)
 HANDLE_DW_OP(0xfc, GNU_const_index, 0, GNU)
 

llvm/include/llvm/IR/DebugInfoMetadata.h

public:
   bool isFragment() const { return getFragmentInfo().hasValue(); }
 
   /// Return whether this is an Implicit Pointer
   bool isImplicitPointer() const {
     return getNumElements() > 0 &&
            (expr_op_begin()->getOp() == dwarf::DW_OP_LLVM_implicit_pointer);
   }
 
+  /// Return whether this is an Implicit Pointer
+  bool isExplicitPointer() const {
+    return getNumElements() > 0 &&
+           (expr_op_begin()->getOp() == dwarf::DW_OP_LLVM_explicit_pointer);
+  }
+
   /// Return whether this is an implicit location description.
   bool isImplicit() const;
 
   /// Return whether the location is computed on the expression stack, meaning
   /// it cannot be a simple register location.
   bool isComplex() const;
 
   /// Append \p Ops with operations to apply the \p Offset.

llvm/include/llvm/IR/IntrinsicInst.h

public:
     /// Returns true if it has an implicit pointer expression
     bool isImplicitPointer() const {
       if (!isa<DIExpression>(getRawExpression()))
         return false;
 
       return getExpression()->isImplicitPointer();
     }
 
+    /// Returns true if it has an explicit pointer expression
+    bool isExplicitPointer() const {
+      if (!isa<DIExpression>(getRawExpression()))
+        return false;
+
+      return getExpression()->isExplicitPointer();
+    }
+
     /// \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:

llvm/lib/CodeGen/AsmPrinter/DebugLocEntry.h

DbgValueLoc(const DIExpression *Expr, const DIVariable *ImpPtr)
     assert(cast<DIExpression>(Expr)->isValid());
   }
 
   bool isLocation() const { return EntryKind == E_Location; }
   bool isInt() const { return EntryKind == E_Integer; }
   bool isConstantFP() const { return EntryKind == E_ConstantFP; }
   bool isConstantInt() const { return EntryKind == E_ConstantInt; }
   bool isImplicitPtr() const { return EntryKind == E_ImplicitPtr; }
+  bool isExplicitPtr() const {
+    const DIExpression *DIExpr = getExpression();
+    return DIExpr ? DIExpr->isExplicitPointer() : false;
+  }
   int64_t getInt() const { return Constant.Int; }
   const ConstantFP *getConstantFP() const { return Constant.CFP; }
   const ConstantInt *getConstantInt() const { return Constant.CIP; }
   MachineLocation getLoc() const { return Loc; }
   const DIVariable *getImplicitPointer() const { return ImpPtr; }
   bool isFragment() const { return getExpression()->isFragment(); }
   bool isEntryVal() const { return getExpression()->isEntryValue(); }
   const DIExpression *getExpression() const { return Expression; }

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

for (const auto &I : DbgValues) {
     // If the history map contains a single debug value, there may be an
     // additional entry which clobbers the debug value.
     // In case of implicit pointer, implicit target can not initialize
     // variable so we need to create location list even in case of single value
     size_t HistSize = HistoryMapEntries.size();
     bool SingleValueWithClobber =
         HistSize == 2 && HistoryMapEntries[1].isClobber();
     if (!MInsn->getDebugExpression()->isImplicitPointer() &&
+        !MInsn->getDebugExpression()->isExplicitPointer() &&
         (HistSize == 1 || SingleValueWithClobber)) {
       const auto *End =
           SingleValueWithClobber ? HistoryMapEntries[1].getInstr() : nullptr;
       if (validThroughout(LScopes, MInsn, End)) {
         RegVar->initializeDbgValue(MInsn);
         continue;
       }
     }
for (const auto &I : DbgValues) {
     bool isValidSingleLocation = buildLocationList(Entries, HistoryMapEntries);
 
     // Check whether buildLocationList managed to merge all locations to one
     // that is valid throughout the variable's scope. If so, produce single
     // value location.
     // In case of implicit pointer, implicit target can not initialize
     // variable so we need to create location list even in case of single value
     if (!MInsn->getDebugExpression()->isImplicitPointer() &&
+        !MInsn->getDebugExpression()->isExplicitPointer() &&
         isValidSingleLocation) {
       RegVar->initializeDbgValue(Entries[0].getValues()[0]);
       continue;
     }
 
     // If the variable has a DIBasicType, extract it.  Basic types cannot have
     // unique identifiers, so don't bother resolving the type with the
     // identifier map.

 
 void DwarfDebug::emitDebugLocValue(const AsmPrinter &AP, const DIBasicType *BT,
                                    const DbgValueLoc &Value,
                                    DwarfExpression &DwarfExpr,
                                    DwarfCompileUnit &TheCU) {
   auto *DIExpr = Value.getExpression();
   DIExpressionCursor ExprCursor(DIExpr);
   DwarfExpr.addFragmentOffset(DIExpr);
+
+  if (Value.isExplicitPtr())
+    DwarfExpr.emitExplicitPointer(std::move(ExprCursor));
+
   // Regular entry.
   if (Value.isInt()) {
     if (BT && (BT->getEncoding() == dwarf::DW_ATE_signed ||
                BT->getEncoding() == dwarf::DW_ATE_signed_char))
       DwarfExpr.addSignedConstant(Value.getInt());
     else
       DwarfExpr.addUnsignedConstant(Value.getInt());
   } else if (Value.isLocation()) {
void DwarfDebug::emitDebugLocValue(const AsmPrinter &AP, const DIBasicType *BT,
   } else if (Value.isImplicitPtr()) {
     const llvm::DIVariable *ImpVar = Value.getImplicitPointer();
     unsigned ValOffset = TheCU.findOrInsertImplicitVar(ImpVar);
     // This works as dummy offset in first operand of DW_OP_implicit_pointer
     // this will later be replace by actual offset of variable in .debug_info
     DwarfExpr.emitImplicitPointer(std::move(ExprCursor), ValOffset);
     return;
   }
+
+  if (!Value.isExplicitPtr())
     DwarfExpr.addExpression(std::move(ExprCursor));
 }
 
 void DebugLocEntry::finalize(const AsmPrinter &AP,
                              DebugLocStream::ListBuilder &List,
                              const DIBasicType *BT,
                              DwarfCompileUnit &TheCU) {
   assert(!Values.empty() &&
          "location list entries without values are redundant");

llvm/lib/CodeGen/AsmPrinter/DwarfExpression.h

public:
 
   /// If applicable, emit an empty DW_OP_piece / DW_OP_bit_piece to advance to
   /// the fragment described by \c Expr.
   void addFragmentOffset(const DIExpression *Expr);
 
   void emitLegacySExt(unsigned FromBits);
   void emitLegacyZExt(unsigned FromBits);
   void emitImplicitPointer(DIExpressionCursor &&Expr, unsigned ValOffset);
+  void emitExplicitPointer(DIExpressionCursor &&Expr);
 };
 
 /// DwarfExpression implementation for .debug_loc entries.
 class DebugLocDwarfExpression final : public DwarfExpression {
 
   struct TempBuffer {
     SmallString<32> Bytes;
     std::vector<std::string> Comments;

llvm/lib/CodeGen/AsmPrinter/DwarfExpression.cpp

void DwarfExpression::emitImplicitPointer(DIExpressionCursor &&ExprCursor,
 
   emitOp(dwarf::DW_OP_implicit_pointer);
   // This is a dummy offset which will be replaced with actual offset in
   // function DwarfDebug::emitDebugLocEntry.
   emitAddressRef(ValOffset);
   emitSigned(Op->getArg(1));
   return;
 }
+
+void DwarfExpression::emitExplicitPointer(DIExpressionCursor &&ExprCursor) {
+  auto Op = ExprCursor.take();
+  assert(Op->getOp() == dwarf::DW_OP_LLVM_explicit_pointer &&
+         "not dwarf::DW_OP_LLVM_explicit_pointer");
+
+  emitOp(dwarf::DW_OP_LLVM_explicit_pointer);
+  return;
+}

llvm/lib/DebugInfo/DWARF/DWARFExpression.cpp

static DescVector getDescriptions() {
   Descriptions[DW_OP_GNU_addr_index] = Desc(Op::Dwarf4, Op::SizeLEB);
   Descriptions[DW_OP_GNU_const_index] = Desc(Op::Dwarf4, Op::SizeLEB);
   Descriptions[DW_OP_GNU_entry_value] = Desc(Op::Dwarf4, Op::SizeLEB);
 
   Descriptions[DW_OP_convert] = Desc(Op::Dwarf5, Op::BaseTypeRef);
   Descriptions[DW_OP_entry_value] = Desc(Op::Dwarf5, Op::SizeLEB);
   Descriptions[DW_OP_implicit_pointer] =
       Desc(Op::Dwarf5, Op::SizeRefAddr, Op::SignedSizeLEB);
+  Descriptions[DW_OP_LLVM_explicit_pointer] = Desc(Op::Dwarf5);
 
   return Descriptions;
 }
 
 static DWARFExpression::Operation::Description getOpDesc(unsigned OpCode) {
   // FIXME: Make this constexpr once all compilers are smart enough to do it.
   static DescVector Descriptions = getDescriptions();
   // Handle possible corrupted or unsupported operation.

llvm/lib/IR/AsmWriter.cpp

for (auto I = N->expr_op_begin(), E = N->expr_op_end(); I != E; ++I) {
 
       Out << FS << OpStr;
       if (I->getOp() == dwarf::DW_OP_LLVM_convert) {
         Out << FS << I->getArg(0);
         Out << FS << dwarf::AttributeEncodingString(I->getArg(1));
       } else if (I->getOp() == dwarf::DW_OP_LLVM_implicit_pointer) {
         Out << FS << dwarf::OperationEncodingString(I->getArg(0));
         Out << FS << I->getArg(1);
+      } else if (I->getOp() == dwarf::DW_OP_LLVM_explicit_pointer) {
+        Out << FS << dwarf::OperationEncodingString(I->getArg(0));
       } else {
         for (unsigned A = 0, AE = I->getNumArgs(); A != AE; ++A)
           Out << FS << I->getArg(A);
       }
     }
   } else {
     for (const auto &I : N->getElements())
       Out << FS << I;

llvm/lib/IR/DebugInfoMetadata.cpp

case dwarf::DW_OP_LLVM_implicit_pointer:
     return 3;
   case dwarf::DW_OP_constu:
   case dwarf::DW_OP_consts:
   case dwarf::DW_OP_deref_size:
   case dwarf::DW_OP_plus_uconst:
   case dwarf::DW_OP_LLVM_tag_offset:
   case dwarf::DW_OP_LLVM_entry_value:
   case dwarf::DW_OP_regx:
+  case dwarf::DW_OP_LLVM_explicit_pointer:
     return 2;
   default:
     return 1;
   }
 }
 
 bool DIExpression::isValid() const {
   for (auto I = expr_op_begin(), E = expr_op_end(); I != E; ++I) {
case dwarf::DW_OP_LLVM_entry_value: {
       // An entry value operator must appear at the beginning and the number of
       // operations it cover can currently only be 1, because we support only
       // entry values of a simple register location. One reason for this is that
       // we currently can't calculate the size of the resulting DWARF block for
       // other expressions.
       return I->get() == expr_op_begin()->get() && I->getArg(0) == 1 &&
              getNumElements() == 2;
     }
+    case dwarf::DW_OP_LLVM_explicit_pointer: {
+      // A DW_OP_LLVM_explicit_pointer operator must appear at the beginning
+      return I == expr_op_begin();
+    }
     case dwarf::DW_OP_LLVM_implicit_pointer: {
       // A DW_OP_LLVM_implicit_pointer operator must appear at the beginning
       // and it has two arguments, DW_OP_LLVM_arg0 and offset N.
       return (I == expr_op_begin()) &&
              (I->getArg(0) == dwarf::DW_OP_LLVM_arg0) &&
              (getNumElements() == 3);
     }
     case dwarf::DW_OP_LLVM_convert:

llvm/lib/IR/IntrinsicInst.cpp

Value *DbgVariableIntrinsic::getVariableLocation(bool AllowNullOp) const {
   return nullptr;
 }
 
 Value *DbgVariableIntrinsic::getDerefVariable(bool AllowNullOp) const {
   Value *Op = getArgOperand(0);
   if (AllowNullOp && !Op)
     return nullptr;
 
+  if (isImplicitPointer())
     return Op;
+
+  auto *MD = cast<MetadataAsValue>(Op)->getMetadata();
+  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;
 }
 
 Optional<uint64_t> DbgVariableIntrinsic::getFragmentSizeInBits() const {
   if (auto Fragment = getExpression()->getFragmentInfo())
     return Fragment->SizeInBits;
   return getVariable()->getSizeInBits();
 }
 

llvm/lib/Transforms/Utils/PromoteMemoryToRegister.cpp

static bool rewriteSingleStoreAlloca(AllocaInst *AI, AllocaInfo &Info,
 
   // Record debuginfo for the store and remove the declaration's
   // debuginfo.
   for (DbgVariableIntrinsic *DII : Info.DbgDeclares) {
     DIBuilder DIB(*AI->getModule(), /*AllowUnresolved*/ false);
     ConvertDebugDeclareToDebugValue(DII, Info.OnlyStore, DIB);
     DII->eraseFromParent();
   }
+
+  // If there is not dbg.declare then it can be case of temp being
+  // promoted, lets record debuginfo
+  if ((AI->getModule()->getDwarfVersion() >= 5) && !Info.DbgDeclares.size()) {
+    Value *ValAddr = OnlyStore->getOperand(1);
+    Value *ReplVal = OnlyStore->getOperand(0);
+    auto &Ctx = AI->getContext();
+    SmallVector<DbgVariableIntrinsic *, 1> DbgUsers;
+    findDbgUsers(DbgUsers, ValAddr);
+    for (auto *DII : DbgUsers) {
+      DIExpression *DIExpr = DII->getExpression();
+      if (DIExpr->getNumElements() == 0) {
+        SmallVector<uint64_t, 8> Ops;
+        Ops.push_back(dwarf::DW_OP_LLVM_explicit_pointer);
+        Ops.push_back(dwarf::DW_OP_LLVM_arg0);
+        DIExpression *DIExprNew = DIExpression::get(DIExpr->getContext(), Ops);
+        DIBuilder DIB(*AI->getModule(), /*AllowUnresolved*/ false);
+        DIB.insertDbgDerefValueIntrinsic(
+            MetadataAsValue::get(Ctx, ValueAsMetadata::get(ReplVal)),
+            DII->getVariable(), DIExprNew, DII->getDebugLoc(), DII);
+      }
+    }
+  }
+
   // Remove the (now dead) store and alloca.
   Info.OnlyStore->eraseFromParent();
   LBI.deleteValue(Info.OnlyStore);
 
   AI->eraseFromParent();
   return true;
 }
 

llvm/test/DebugInfo/dwarfdump_explicit_pointer.ll

+; RUN: llc %s -O2 -filetype=obj -o %t.o
+; RUN: llvm-dwarfdump  %t.o | FileCheck %s
+
+; CHECK:     :  DW_OP_LLVM_explicit_pointer, DW_OP_lit3
+
+; Below is the original test case this IR is generated from
+;----------------------------------------------------------
+;__attribute__((optnone)) int source() {
+;  return 3;
+;}
+;__attribute__((optnone)) void f(int i) {
+;}
+;inline void sink(const int& p) {
+;  f(p);
+;}
+;int main() {
+;  sink(source());
+;}
+;----------------------------------------------------------
+
+; ModuleID = 'explicit_pointer.cc'
+source_filename = "explicit_pointer.cc"
+target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+; Function Attrs: noinline nounwind optnone uwtable
+define dso_local i32 @_Z6sourcev() local_unnamed_addr !dbg !7 {
+entry:
+  ret i32 3, !dbg !11
+}
+
+; Function Attrs: noinline nounwind optnone uwtable
+define dso_local void @_Z1fi(i32 %i) local_unnamed_addr !dbg !12 {
+entry:
+  %i.addr = alloca i32, align 4
+  store i32 %i, i32* %i.addr, align 4, !tbaa !17
+  call void @llvm.dbg.declare(metadata i32* %i.addr, metadata !16, metadata !DIExpression()), !dbg !21
+  ret void, !dbg !22
+}
+
+; Function Attrs: nounwind readnone speculatable willreturn
+declare void @llvm.dbg.declare(metadata, metadata, metadata)
+
+; Function Attrs: norecurse nounwind uwtable
+define dso_local i32 @main() local_unnamed_addr !dbg !23 {
+entry:
+  %call = tail call i32 @_Z6sourcev(), !dbg !24
+  call void @llvm.dbg.derefval(metadata i32 3, metadata !25, metadata !DIExpression(DW_OP_LLVM_explicit_pointer, DW_OP_LLVM_arg0)), !dbg !32
+  tail call void @_Z1fi(i32 3) #3, !dbg !34
+  ret i32 0, !dbg !35
+}
+
+; Function Attrs: nounwind readnone speculatable willreturn
+declare void @llvm.dbg.derefval(metadata, metadata, metadata)
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!3, !4, !5}
+!llvm.ident = !{!6}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !1, producer: "clang version 10.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, nameTableKind: None)
+!1 = !DIFile(filename: "explicit_pointer.cc", directory: "/dir")
+!2 = !{}
+!3 = !{i32 7, !"Dwarf Version", i32 4}
+!4 = !{i32 2, !"Debug Info Version", i32 3}
+!5 = !{i32 1, !"wchar_size", i32 4}
+!6 = !{!"clang version 10.0.0"}
+!7 = distinct !DISubprogram(name: "source", linkageName: "_Z6sourcev", scope: !1, file: !1, line: 1, type: !8, scopeLine: 1, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !2)
+!8 = !DISubroutineType(types: !9)
+!9 = !{!10}
+!10 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!11 = !DILocation(line: 2, column: 3, scope: !7)
+!12 = distinct !DISubprogram(name: "f", linkageName: "_Z1fi", scope: !1, file: !1, line: 4, type: !13, scopeLine: 4, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !15)
+!13 = !DISubroutineType(types: !14)
+!14 = !{null, !10}
+!15 = !{!16}
+!16 = !DILocalVariable(name: "i", arg: 1, scope: !12, file: !1, line: 4, type: !10)
+!17 = !{!18, !18, i64 0}
+!18 = !{!"int", !19, i64 0}
+!19 = !{!"omnipotent char", !20, i64 0}
+!20 = !{!"Simple C++ TBAA"}
+!21 = !DILocation(line: 4, column: 37, scope: !12)
+!22 = !DILocation(line: 5, column: 1, scope: !12)
+!23 = distinct !DISubprogram(name: "main", scope: !1, file: !1, line: 9, type: !8, scopeLine: 9, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !2)
+!24 = !DILocation(line: 10, column: 8, scope: !23)
+!25 = !DILocalVariable(name: "p", arg: 1, scope: !26, file: !1, line: 6, type: !29)
+!26 = distinct !DISubprogram(name: "sink", linkageName: "_Z4sinkRKi", scope: !1, file: !1, line: 6, type: !27, scopeLine: 6, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !31)
+!27 = !DISubroutineType(types: !28)
+!28 = !{null, !29}
+!29 = !DIDerivedType(tag: DW_TAG_reference_type, baseType: !30, size: 64)
+!30 = !DIDerivedType(tag: DW_TAG_const_type, baseType: !10)
+!31 = !{!25}
+!32 = !DILocation(line: 0, scope: !26, inlinedAt: !33)
+!33 = distinct !DILocation(line: 10, column: 3, scope: !23)
+!34 = !DILocation(line: 7, column: 3, scope: !26, inlinedAt: !33)
+!35 = !DILocation(line: 11, column: 1, scope: !23)

llvm/test/DebugInfo/explicit_pointer.cc

+// RUN: clang %s -O2 -gdwarf-5 -S -emit-llvm -o %t.ll
+// RUN: FileCheck %s --input-file=%t.ll
+
+// CHECK:   call void @llvm.dbg.derefval(metadata i32 3, {{.+}} !DIExpression(DW_OP_LLVM_explicit_pointer, DW_OP_LLVM_arg0)
+
+__attribute__((optnone)) int source() {
+  return 3;
+}
+__attribute__((optnone)) void f(int i) {
+}
+inline void sink(const int& p) {
+  f(p);
+}
+int main() {
+  sink(source());
+}