[DWARF] Handle DW_OP_entry_value operand

[djtodoro]

Summary

IR and AsmPrinter parts for handling of DW_OP_entry_values DWARF operation.

Authors: @asowda, @NikolaPrica, @djtodoro, @ivanbaev

[aprantl]

This looks mostly good, IMO what's missing is

• an entry in SourceLevelDebugging.rst (or LangRef.rst?) explaining the semantics and limitations of our DW_OP_entry_value support
• a Verifier check that yells when a DW_OP_entry_value is not at position 0
• bonus points for refactoring the With* parameters to a flag enum that is slightly less error-prone to use.

[djtodoro]

This looks mostly good, IMO what's missing is

Thanks!

an entry in SourceLevelDebugging.rst (or LangRef.rst?) explaining the semantics and limitations of our DW_OP_entry_value support

Done.

a Verifier check that yells when a DW_OP_entry_value is not at position 0

Done.

bonus points for refactoring the With* parameters to a flag enum that is slightly less error-prone to use.

Since there are a lot of places using With* it is better doing this as a separate commit. I am working on the patch. :)

[djtodoro]

-Add documentation
-Add a verifier check

[aprantl]

docs/LangRef.rst

4697 ↗

(On Diff #196429)

How about:

If an expression is marked with ``DW_OP_entry_value `` all register and memory read operations refer to the respective value at the function entry. ``DW_OP_entry_value `` may only appear after instruction selection. At this point LLVM only supports entry values for function parameters that are unmodified throughout a function and that are described as simple register location descriptions.

4700 ↗

(On Diff #196429)

The Verifier must enforce this.

[aprantl]

lib/IR/DebugInfoMetadata.cpp

880 ↗

(On Diff #196429)

Also, we must enforce the "simple register location" property.

[djtodoro]

@aprantl Thanks again for the comments!

Let us summarize the whole picture of the feature here. In .debug_info section DW_TAG_call_site_parameter information with its attributes allows us to print @entry value from a debugger (e.g. #1 foo (val=<optimized out>, val@entry=5)). That information we try to generate during AsmPrinter phase.

The second thing of the feature is using @entry for representing real value (DBG_VALUE) of a parameter (additional input in .debug_loc). It is done by generating additional DW_OP_entry_value in LiveDebugValues. So, it will allow us to see situations in a backtrace such as #1 foo (val=val@entry=5).

In addition, we see that GCC in some situations generate DW_OP_entry_value for representing call site parameters value (see DwarfDebug.cpp file), but that is an enhancement, not a fundamental thing.

docs/LangRef.rst

4697 ↗

(On Diff #196429)

This?

If an expression is marked with DW_OP_entry_value all register and memory read operations refer to the respective value at the function entry. DW_OP_entry_value may appear after livedebugvalues pass. At this point LLVM only supports entry values for function parameters that are unmodified throughout a function and that are described as simple register location descriptions. DW_OP_entry_value may also appear after asembler printer phase when a call site parameter value (DW_AT_call_site_parameter_value) is representd as entry value of the parameter.

In addition, we should add documentation for DW_TAG_call_site and DW_TAG_call_site_parameter as well.

4700 ↗

(On Diff #196429)

I think that it is hard to verify it at this place. Maybe when printing DWARF expression ?

[aprantl]

docs/LangRef.rst

4697 ↗

(On Diff #196429)

typos: assembler and represented

I realized that there are more things that we need to add:

Before DW_OP_entry_value, DIExpression did not support DW_OP_reg or similar, but if I understand correctly the idea is that LiveDebugValues will now directly inject register operations into the expression. If that's so:

1. we need to also document which DW_OP_reg operations are supported
2. verify that they only appear after a DW_OP_entry_value
3. We need to document what the value of the first argument of DW_OP_entry_value is

4700 ↗

(On Diff #196429)

Can you explain why? DIExpression::isValid() walks the entire expression. When we encounter a DW_OP_entry_value, we enforce that the next arg0 elements are out of a limited set of operations. Would that work?

[dstenb]

lib/CodeGen/AsmPrinter/DwarfExpression.cpp

354 ↗

(On Diff #196429)

This appears to be an unintentional change (which does not compile).

[djtodoro]

docs/LangRef.rst

4697 ↗

(On Diff #196429)

I think we should document usage of DW_OP_reg. It introduces a confusion here. The operand is used only at the place where we are trying to describe loaded value into parameter's forwarding register (expression of DW_AT_call_site_parameter_value used for printing @entry in debugger). So, the operand could appear in DIExpression after describeLoadedValue() called from DwarfDebug::collectCallSiteParameters(). Basically, DwarfDebug::collectCallSiteParameters() is the place where we prepare info for producing DW_TAG_call_site_parameter, but within LiveDebugValues we generate just additional entries (with DW_OP_entry_value) in .debug_loc that should try using benefits of DW_TAG_call_site_parameter debug info (it means we should try reconstructing a real value for the parameter from @entry).

After LiveDebugValues pass, entry value DIExpression could have only DW_OP_entry_value operand, but final entry value DWARF expression will be printed over a register from corresponding DBG_VALUE.

4700 ↗

(On Diff #196429)

Entry value DIExpression can have only DW_OP_entry_value for now.

lib/CodeGen/AsmPrinter/DwarfExpression.cpp

354 ↗

(On Diff #196429)

Sure. The mistake was annul with the last patch from the stack. We will update this.

[aprantl]

docs/LangRef.rst

4697 ↗

(On Diff #196429)

Perhaps a reasonable restriction (that we could enforce in the Verifier) would be that DW_OP_reg is only allowed inside a DW_OP_entry_value?

[djtodoro]

docs/LangRef.rst

4697 ↗

(On Diff #196429)

We added a documentation for DW_OP_reg in the last patch of the stack. I think that will clarify picture here. The operand has nothing to do with this part here.
Sorry for the confusion. :)

[djtodoro]

-Refactor the code a bit
-Improve the documentation

[aprantl]

include/llvm/BinaryFormat/Dwarf.def

635 ↗

(On Diff #199219)

This comment is fine.

636 ↗

(On Diff #199219)

We don't usually include links in the comments. This can probably be found with a search anyway.

lib/CodeGen/AsmPrinter/DwarfExpression.cpp

327 ↗

(On Diff #199219)

Could we make this a verifier error instead and an assertion here?

lib/CodeGen/AsmPrinter/DwarfExpression.h

127 ↗

(On Diff #199219)

Can we do this as a separate NFC patch in preparation?

[djtodoro]

@aprantl As soon as NFC patches (D61943 and D62002) got accepted we will update this.

lib/CodeGen/AsmPrinter/DwarfExpression.cpp

327 ↗

(On Diff #199219)

Sure.

lib/CodeGen/AsmPrinter/DwarfExpression.h

127 ↗

(On Diff #199219)

Sure.

[djtodoro]

-Address suggestions
-Improve the documentation
-Improve the verifier

[aprantl]

docs/LangRef.rst

4700 ↗

(On Diff #199793)

... may only appear after the ... pass.

4701 ↗

(On Diff #199793)

LLVM only supports ...

[aprantl]

lib/IR/DebugInfoMetadata.cpp

883 ↗

(On Diff #199793)

Why is it not necessary to check DW_OP_reg here?

[djtodoro]

lib/IR/DebugInfoMetadata.cpp

883 ↗

(On Diff #199793)

At this point, entry value DIExpression could have only DW_OP_entry_value and 1 as the size of following DWARF expression. Since we are supporting only simple register locations the size is always 1 for now. The assembler printer will use the expression and the register operand from the DBG_VALUE (we don't embed the register info into the DIExpression explicitly) when printing it into DWARF section. This is generated during the LiveDebugValues pass to describe normal value of the parameter through the entry value (new special kind of value).

DW_OP_reg that we introduced in the last patch has nothing to do with this part and it is not used here.

[djtodoro]

-Address suggestions

[aprantl]

lib/IR/DebugInfoMetadata.cpp

883 ↗

(On Diff #199793)

I also saw that this is in the other patch later. Thanks for clarifying!

It still looks like we should verify the length / rest of the expression instead of returning without checking the later elements? We're checking the length /argument/ of the entry value, but not that the expression actually has the promised 1 argument and nothing else.

This should also be very simple to test (cf. llvm/test/Verifier/diexpression-swap.ll)

[djtodoro]

-Improve the verifier for entry values
-Add test for the verifier

[aprantl]

include/llvm/IR/DebugInfoMetadata.h

2542 ↗

(On Diff #200488)

Note to self: this is being refactored in another review.

lib/CodeGen/AsmPrinter/DbgEntityHistoryCalculator.cpp

44 ↗

(On Diff #200488)

If "the" location is "an" entry value

lib/DebugInfo/DWARF/DWARFExpression.cpp

278 ↗

(On Diff #200488)

An llvm-dwarfdump test for this would be nice, too.

test/Verifier/diexpression-entry-value.ll

3 ↗

(On Diff #200488)

, !1, !2

5 ↗

(On Diff #200488)

!1 = !DIExpression(DW_OP_constu, 0, DW_OP_entry_value, 1, DW_OP_constu, 0)
!2 = !DIExpression(DW_OP_entry_value, 100, DW_OP_constu, 0)

and then perhaps also a positive test

[djtodoro]

-Addressing comments
-Add llvm-dwarfdump tests for DW_OP_entry_value

TODO: Rebase this on top of NFCs D61943 and D62002

[djtodoro]

-Refactor the code a bit
-Rebase

[aprantl]

include/llvm/IR/DebugInfoMetadata.h

2555 ↗

(On Diff #201512)

/// Check if the expression consists of exactly one entry value operand.
/// (This is the only configuration of entry values that is supported.)

[djtodoro]

-Addressing suggestions

[djtodoro]

-Rebase

llvm/docs/LangRef.rst

 - ``DW_OP_LLVM_tag_offset, tag_offset`` specifies that a memory tag should be
   optionally applied to the pointer. The memory tag is derived from the
   given tag offset in an implementation-defined manner.
 - ``DW_OP_swap`` swaps top two stack entries.
 - ``DW_OP_xderef`` provides extended dereference mechanism. The entry at the top
   of the stack is treated as an address. The second stack entry is treated as an
   address space identifier.
 - ``DW_OP_stack_value`` marks a constant value.
+- If an expression is marked with ``DW_OP_entry_value`` all register and
+  memory read operations refer to the respective value at the function entry.
+  The first operand of ``DW_OP_entry_value`` is the size of following
+  DWARF expression.
+  ``DW_OP_entry_value`` may appear after the ``LiveDebugValues`` pass.
+  LLVM only supports entry values for function parameters
+  that are unmodified throughout a function and that are described as
+  simple register location descriptions.
+  ``DW_OP_entry_value`` may also appear after the ``AsmPrinter`` pass when
+  a call site parameter value (``DW_AT_call_site_parameter_value``)
+  is represented as entry value of the parameter.
 
 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(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 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)
 
 // DWARF languages.
 HANDLE_DW_LANG(0x0001, C89, 0, 2, DWARF)
 HANDLE_DW_LANG(0x0002, C, 0, 2, DWARF)
 HANDLE_DW_LANG(0x0003, Ada83, 1, 2, DWARF)

llvm/include/llvm/IR/DebugInfoMetadata.h

public:
   static const DIExpression *extractAddressClass(const DIExpression *Expr,
                                                  unsigned &AddrClass);
 
   /// Used for DIExpression::prepend.
   enum PrependOps : uint8_t {
     ApplyOffset = 0,
     DerefBefore = 1 << 0,
     DerefAfter = 1 << 1,
-    StackValue = 1 << 2
+    StackValue = 1 << 2,
+    EntryValue = 1 << 3
   };
 
   /// Prepend \p DIExpr with a deref and offset operation and optionally turn it
-  /// into a stack value.
+  /// into a stack value or/and an entry value.
   static DIExpression *prepend(const DIExpression *Expr, uint8_t Flags,
                                int64_t Offset = 0);
 
   /// Prepend \p DIExpr with the given opcodes and optionally turn it into a
   /// stack value.
   static DIExpression *prependOpcodes(const DIExpression *Expr,
                                       SmallVectorImpl<uint64_t> &Ops,
-                                      bool StackValue = false);
+                                      bool StackValue = false,
+                                      bool EntryValue = false);
 
   /// Append the opcodes \p Ops to \p DIExpr. Unlike \ref appendToStack, the
   /// returned expression is a stack value only if \p DIExpr is a stack value.
   /// If \p DIExpr describes a fragment, the returned expression will describe
   /// the same fragment.
   static DIExpression *append(const DIExpression *Expr, ArrayRef<uint64_t> Ops);
 
   /// Convert \p DIExpr into a stack value if it isn't one already by appending
public:
   }
 
   /// Check if fragments overlap between this DIExpression and \p Other.
   bool fragmentsOverlap(const DIExpression *Other) const {
     if (!isFragment() || !Other->isFragment())
       return true;
     return fragmentCmp(Other) == 0;
   }
+
+  /// Check if the expression consists of exactly one entry value operand.
+  /// (This is the only configuration of entry values that is supported.)
+  bool isEntryValue() const {
+    return getNumElements() > 0 &&
+           getElement(0) == dwarf::DW_OP_entry_value;
+  }
 };
 
 inline bool operator==(const DIExpression::FragmentInfo &A,
                        const DIExpression::FragmentInfo &B) {
   return std::tie(A.SizeInBits, A.OffsetInBits) ==
          std::tie(B.SizeInBits, B.OffsetInBits);
 }
 

llvm/lib/CodeGen/AsmPrinter/DbgEntityHistoryCalculator.cpp

 }
 
 // If @MI is a DBG_VALUE with debug value described by a
 // defined register, returns the number of this register.
 // In the other case, returns 0.
 static unsigned isDescribedByReg(const MachineInstr &MI) {
   assert(MI.isDebugValue());
   assert(MI.getNumOperands() == 4);
+  // If the location of variable is an entry value (DW_OP_entry_value)
+  // do not consider it as a register location.
+  if (MI.getDebugExpression()->isEntryValue())
+    return 0;
   // If location of variable is described using a register (directly or
   // indirectly), this register is always a first operand.
   return MI.getOperand(0).isReg() ? MI.getOperand(0).getReg() : 0;
 }
 
 bool DbgValueHistoryMap::startDbgValue(InlinedEntity Var,
                                        const MachineInstr &MI,
                                        EntryIndex &NewIndex) {

llvm/lib/CodeGen/AsmPrinter/DebugLocEntry.h

public:
   bool isInt() const { return EntryKind == E_Integer; }
   bool isConstantFP() const { return EntryKind == E_ConstantFP; }
   bool isConstantInt() const { return EntryKind == E_ConstantInt; }
   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; }
   bool isFragment() const { return getExpression()->isFragment(); }
+  bool isEntryVal() const { return getExpression()->isEntryValue(); }
   const DIExpression *getExpression() const { return Expression; }
   friend bool operator==(const DbgValueLoc &, const DbgValueLoc &);
   friend bool operator<(const DbgValueLoc &, const DbgValueLoc &);
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
   LLVM_DUMP_METHOD void dump() const {
     if (isLocation()) {
       llvm::dbgs() << "Loc = { reg=" << Loc.getReg() << " ";
       if (Loc.isIndirect())

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.h

 
 namespace llvm {
 
 class AsmPrinter;
 class ByteStreamer;
 class DebugLocEntry;
 class DIE;
 class DwarfCompileUnit;
+class DwarfExpression;
 class DwarfTypeUnit;
 class DwarfUnit;
 class LexicalScope;
 class MachineFunction;
 class MCSection;
 class MCSymbol;
 class MDNode;
 class Module;
public:
   /// @{
   bool tuneForGDB() const { return DebuggerTuning == DebuggerKind::GDB; }
   bool tuneForLLDB() const { return DebuggerTuning == DebuggerKind::LLDB; }
   bool tuneForSCE() const { return DebuggerTuning == DebuggerKind::SCE; }
   /// @}
 
   void addSectionLabel(const MCSymbol *Sym);
   const MCSymbol *getSectionLabel(const MCSection *S);
+
+  static void emitDebugLocValue(const AsmPrinter &AP, const DIBasicType *BT,
+                                const DbgValueLoc &Value,
+                                DwarfExpression &DwarfExpr);
 };
 
 } // end namespace llvm
 
 #endif // LLVM_LIB_CODEGEN_ASMPRINTER_DWARFDEBUG_H

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

for (unsigned I = 0; I < 2; ++I) {
           Streamer.EmitInt8(Data.getData()[J], Comment != End ? *(Comment++) : "");
       }
       Offset = Op.getOperandEndOffset(I);
     }
     assert(Offset == Op.getEndOffset());
   }
 }
 
-static void emitDebugLocValue(const AsmPrinter &AP, const DIBasicType *BT,
+void DwarfDebug::emitDebugLocValue(const AsmPrinter &AP, const DIBasicType *BT,
                                    const DbgValueLoc &Value,
                                    DwarfExpression &DwarfExpr) {
   auto *DIExpr = Value.getExpression();
   DIExpressionCursor ExprCursor(DIExpr);
   DwarfExpr.addFragmentOffset(DIExpr);
   // 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()) {
     MachineLocation Location = Value.getLoc();
     if (Location.isIndirect())
       DwarfExpr.setMemoryLocationKind();
     DIExpressionCursor Cursor(DIExpr);
+
+    if (DIExpr->isEntryValue()) {
+      DwarfExpr.setEntryValueFlag();
+      DwarfExpr.addEntryValueExpression(Cursor);
+    }
+
     const TargetRegisterInfo &TRI = *AP.MF->getSubtarget().getRegisterInfo();
     if (!DwarfExpr.addMachineRegExpression(TRI, Cursor, Location.getReg()))
       return;
     return DwarfExpr.addExpression(std::move(Cursor));
   } else if (Value.isConstantFP()) {
     APInt RawBytes = Value.getConstantFP()->getValueAPF().bitcastToAPInt();
     DwarfExpr.addUnsignedConstant(RawBytes);
   }
if (Value.isFragment()) {
     // Emit all fragments that belong to the same variable and range.
     assert(llvm::all_of(Values, [](DbgValueLoc P) {
           return P.isFragment();
         }) && "all values are expected to be fragments");
     assert(std::is_sorted(Values.begin(), Values.end()) &&
            "fragments are expected to be sorted");
 
     for (auto Fragment : Values)
-      emitDebugLocValue(AP, BT, Fragment, DwarfExpr);
+      DwarfDebug::emitDebugLocValue(AP, BT, Fragment, DwarfExpr);
 
   } else {
     assert(Values.size() == 1 && "only fragments may have >1 value");
-    emitDebugLocValue(AP, BT, Value, DwarfExpr);
+    DwarfDebug::emitDebugLocValue(AP, BT, Value, DwarfExpr);
   }
   DwarfExpr.finalize();
 }
 
 void DwarfDebug::emitDebugLocEntryLocation(const DebugLocStream::Entry &Entry,
                                            const DwarfCompileUnit *CU) {
   // Emit the size.
   Asm->OutStreamer->AddComment("Loc expr size");

llvm/lib/CodeGen/AsmPrinter/DwarfExpression.h

protected:
 
   /// Sometimes we need to add a DW_OP_bit_piece to describe a subregister.
   unsigned SubRegisterSizeInBits : 16;
   unsigned SubRegisterOffsetInBits : 16;
 
   /// The kind of location description being produced.
   enum { Unknown = 0, Register, Memory, Implicit };
 
+  /// The flags of location description being produced.
+  enum { EntryValue = 1 };
+
   unsigned LocationKind : 3;
   unsigned LocationFlags : 2;
   unsigned DwarfVersion : 4;
 
 public:
   bool isUnknownLocation() const {
     return LocationKind == Unknown;
   }
 
   bool isMemoryLocation() const {
     return LocationKind == Memory;
   }
 
   bool isRegisterLocation() const {
     return LocationKind == Register;
   }
 
   bool isImplicitLocation() const {
     return LocationKind == Implicit;
   }
 
+  bool isEntryValue() const {
+    return LocationFlags & EntryValue;
+  }
+
   Optional<uint8_t> TagOffset;
 
 protected:
   /// Push a DW_OP_piece / DW_OP_bit_piece for emitting later, if one is needed
   /// to represent a subregister.
   void setSubRegisterPiece(unsigned SizeInBits, unsigned OffsetInBits) {
     assert(SizeInBits < 65536 && OffsetInBits < 65536);
     SubRegisterSizeInBits = SizeInBits;
public:
   void addUnsignedConstant(const APInt &Value);
 
   /// Lock this down to become a memory location description.
   void setMemoryLocationKind() {
     assert(isUnknownLocation());
     LocationKind = Memory;
   }
 
+  /// Lock this down to become an entry value location.
+  void setEntryValueFlag() {
+    LocationFlags |= EntryValue;
+  }
+
   /// Emit a machine register location. As an optimization this may also consume
   /// the prefix of a DwarfExpression if a more efficient representation for
   /// combining the register location and the first operation exists.
   ///
   /// \param FragmentOffsetInBits     If this is one fragment out of a
   /// fragmented
   ///                                 location, this is the offset of the
   ///                                 fragment inside the entire variable.
   /// \return                         false if no DWARF register exists
   ///                                 for MachineReg.
   bool addMachineRegExpression(const TargetRegisterInfo &TRI,
                                DIExpressionCursor &Expr, unsigned MachineReg,
                                unsigned FragmentOffsetInBits = 0);
 
+  /// Emit entry value dwarf operation.
+  void addEntryValueExpression(DIExpressionCursor &ExprCursor);
+
   /// Emit all remaining operations in the DIExpressionCursor.
   ///
   /// \param FragmentOffsetInBits     If this is one fragment out of multiple
   ///                                 locations, this is the offset of the
   ///                                 fragment inside the entire variable.
   void addExpression(DIExpressionCursor &&Expr,
                      unsigned FragmentOffsetInBits = 0);
 

llvm/lib/CodeGen/AsmPrinter/DwarfExpression.cpp

bool DwarfExpression::addMachineRegExpression(const TargetRegisterInfo &TRI,
 
   // Handle simple register locations.
   if (!isMemoryLocation() && !HasComplexExpression) {
     for (auto &Reg : DwarfRegs) {
       if (Reg.DwarfRegNo >= 0)
         addReg(Reg.DwarfRegNo, Reg.Comment);
       addOpPiece(Reg.Size);
     }
+
+    if (isEntryValue() && DwarfVersion >= 4)
+      emitOp(dwarf::DW_OP_stack_value);
+
     DwarfRegs.clear();
     return true;
   }
 
   // Don't emit locations that cannot be expressed without DW_OP_stack_value.
   if (DwarfVersion < 4)
     if (any_of(ExprCursor, [](DIExpression::ExprOperand Op) -> bool {
           return Op.getOp() == dwarf::DW_OP_stack_value;
bool DwarfExpression::addMachineRegExpression(const TargetRegisterInfo &TRI,
   if (FBReg)
     addFBReg(SignedOffset);
   else
     addBReg(Reg.DwarfRegNo, SignedOffset);
   DwarfRegs.clear();
   return true;
 }
 
+void DwarfExpression::addEntryValueExpression(DIExpressionCursor &ExprCursor) {
+  auto Op = ExprCursor.take();
+  assert(Op && Op->getOp() == dwarf::DW_OP_entry_value);
+  assert(!isMemoryLocation() &&
+         "We don't support entry values of memory locations yet");
+
+  if (DwarfVersion >= 5)
+    emitOp(dwarf::DW_OP_entry_value);
+  else
+    emitOp(dwarf::DW_OP_GNU_entry_value);
+  emitUnsigned(Op->getArg(0));
+}
+
 /// Assuming a well-formed expression, match "DW_OP_deref* DW_OP_LLVM_fragment?".
 static bool isMemoryLocation(DIExpressionCursor ExprCursor) {
   while (ExprCursor) {
     auto Op = ExprCursor.take();
     switch (Op->getOp()) {
     case dwarf::DW_OP_deref:
     case dwarf::DW_OP_LLVM_fragment:
       break;

llvm/lib/DebugInfo/DWARF/DWARFExpression.cpp

static DescVector getDescriptions() {
   Descriptions[DW_OP_bit_piece] = Desc(Op::Dwarf3, Op::SizeLEB, Op::SizeLEB);
   Descriptions[DW_OP_implicit_value] =
       Desc(Op::Dwarf3, Op::SizeLEB, Op::SizeBlock);
   Descriptions[DW_OP_stack_value] = Desc(Op::Dwarf3);
   Descriptions[DW_OP_GNU_push_tls_address] = Desc(Op::Dwarf3);
   Descriptions[DW_OP_addrx] = Desc(Op::Dwarf4, Op::SizeLEB);
   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);
 
   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.
if (Size == Operation::BaseTypeRef && U) {
       }
     } else if (Size == Operation::SizeBlock) {
       uint32_t Offset = Operands[Operand];
       for (unsigned i = 0; i < Operands[Operand - 1]; ++i)
         OS << format(" 0x%02x", Expr->Data.getU8(&Offset));
     } else {
       if (Signed)
         OS << format(" %+" PRId64, (int64_t)Operands[Operand]);
-      else
+      else if (Opcode != DW_OP_entry_value &&
+               Opcode != DW_OP_GNU_entry_value)
         OS << format(" 0x%" PRIx64, Operands[Operand]);
     }
   }
   return true;
 }
 
 void DWARFExpression::print(raw_ostream &OS, const MCRegisterInfo *RegInfo,
                             DWARFUnit *U, bool IsEH) const {
+  uint32_t EntryValExprSize = 0;
   for (auto &Op : *this) {
     if (!Op.print(OS, this, RegInfo, U, IsEH)) {
       uint32_t FailOffset = Op.getEndOffset();
       while (FailOffset < Data.getData().size())
         OS << format(" %02x", Data.getU8(&FailOffset));
       return;
     }
+
+    if (Op.getCode() == DW_OP_entry_value ||
+        Op.getCode() == DW_OP_GNU_entry_value) {
+      OS << "(";
+      EntryValExprSize = Op.getRawOperand(0);
+      continue;
+    }
+
+    if (EntryValExprSize) {
+      EntryValExprSize--;
+      if (EntryValExprSize == 0)
+        OS << ")";
+    }
+
     if (Op.getEndOffset() < Data.getData().size())
       OS << ", ";
   }
 }
 
 bool DWARFExpression::Operation::verify(DWARFUnit *U) {
 
   for (unsigned Operand = 0; Operand < 2; ++Operand) {

llvm/lib/IR/DebugInfoMetadata.cpp

unsigned DIExpression::ExprOperand::getSize() const {
   switch (getOp()) {
   case dwarf::DW_OP_LLVM_convert:
   case dwarf::DW_OP_LLVM_fragment:
     return 3;
   case dwarf::DW_OP_constu:
   case dwarf::DW_OP_deref_size:
   case dwarf::DW_OP_plus_uconst:
   case dwarf::DW_OP_LLVM_tag_offset:
+  case dwarf::DW_OP_entry_value:
     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_swap: {
       // that keeps track of the stack depth and introduce something like a
       // DW_LLVM_OP_implicit_location as a placeholder for the location this
       // DIExpression is attached to, or else pass the number of implicit stack
       // elements into isValid.
       if (getNumElements() == 1)
         return false;
       break;
     }
+    case dwarf::DW_OP_entry_value: {
+      // An entry value operator must appear at the begin and the size
+      // of following expression should be 1, because we support only
+      // entry values of a simple register location.
+      return I->get() == expr_op_begin()->get() && I->getArg(0) == 1 &&
+             getNumElements() == 2;
+    }
     case dwarf::DW_OP_LLVM_convert:
     case dwarf::DW_OP_LLVM_tag_offset:
     case dwarf::DW_OP_constu:
     case dwarf::DW_OP_plus_uconst:
     case dwarf::DW_OP_plus:
     case dwarf::DW_OP_minus:
     case dwarf::DW_OP_mul:
     case dwarf::DW_OP_div:
DIExpression *DIExpression::prepend(const DIExpression *Expr, uint8_t Flags,
   if (Flags & DIExpression::DerefBefore)
     Ops.push_back(dwarf::DW_OP_deref);
 
   appendOffset(Ops, Offset);
   if (Flags & DIExpression::DerefAfter)
     Ops.push_back(dwarf::DW_OP_deref);
 
   bool StackValue = Flags & DIExpression::StackValue;
+  bool EntryValue = Flags & DIExpression::EntryValue;
 
-  return prependOpcodes(Expr, Ops, StackValue);
+  return prependOpcodes(Expr, Ops, StackValue, EntryValue);
 }
 
 DIExpression *DIExpression::prependOpcodes(const DIExpression *Expr,
                                            SmallVectorImpl<uint64_t> &Ops,
-                                           bool StackValue) {
+                                           bool StackValue,
+                                           bool EntryValue) {
   assert(Expr && "Can't prepend ops to this expression");
 
+  if (EntryValue) {
+    Ops.push_back(dwarf::DW_OP_entry_value);
+    // Add size info needed for entry value expression.
+    // Add plus one for target register operand.
+    Ops.push_back(Expr->getNumElements() + 1);
+  }
+
   // If there are no ops to prepend, do not even add the DW_OP_stack_value.
   if (Ops.empty())
     StackValue = false;
   for (auto Op : Expr->expr_ops()) {
     // A DW_OP_stack_value comes at the end, but before a DW_OP_LLVM_fragment.
     if (StackValue) {
       if (Op.getOp() == dwarf::DW_OP_stack_value)
         StackValue = false;

llvm/test/Verifier/diexpression-entry-value.ll

+; RUN: not opt -S < %s 2>&1 | FileCheck %s
+
+!named = !{!0, !1, !2}
+; CHECK: invalid expression
+!0 = !DIExpression(DW_OP_entry_value, 4, DW_OP_constu, 0, DW_OP_stack_value)
+!1 = !DIExpression(DW_OP_constu, 0, DW_OP_entry_value, 1, DW_OP_constu, 0)
+!2 = !DIExpression(DW_OP_entry_value, 100, DW_OP_constu, 0)

llvm/test/Verifier/diexpression-valid-entry-value.ll

+; RUN: opt -S < %s 2>&1 | FileCheck %s
+
+!named = !{!0}
+; CHECK-NOT: invalid expression
+!0 = !DIExpression(DW_OP_entry_value, 1)

llvm/test/tools/llvm-dwarfdump/X86/debug_loc_OP_GNU_entry_value.s

+# RUN: llvm-mc -triple x86_64-pc-linux %s -filetype=obj | llvm-dwarfdump - | FileCheck %s
+#
+# CHECK: DW_TAG_variable
+# CHECK-NEXT: DW_AT_name ("a")
+# CHECK-NEXT: DW_AT_location
+# CHECK-NEXT: DW_OP_GNU_entry_value(DW_OP_reg5 RDI), DW_OP_stack_value)
+
+  .section  .debug_str,"MS",@progbits,1
+.Linfo_producer:
+  .asciz  "hand-written DWARF"
+.Lname_a:
+  .asciz  "a"
+
+  .section  .debug_loc,"",@progbits
+.Ldebug_loc0:
+  .quad 0
+  .quad 1
+  .short  .Lloc0_end-.Lloc0_start # Loc expr size
+.Lloc0_start:
+  .byte 243                     # DW_OP_GNU_entry_value
+  .byte 1                       # 1
+  .byte 85                      # super-register DW_OP_reg5
+  .byte 159                     # DW_OP_stack_value
+.Lloc0_end:
+  .quad 0
+  .quad 0
+  .section  .debug_abbrev,"",@progbits
+  .byte 1                       # Abbreviation Code
+  .byte 17                      # DW_TAG_compile_unit
+  .byte 1                       # DW_CHILDREN_yes
+  .byte 37                      # DW_AT_producer
+  .byte 14                      # DW_FORM_strp
+  .byte 0                       # EOM(1)
+  .byte 0                       # EOM(2)
+  .byte 5                       # Abbreviation Code
+  .byte 52                      # DW_TAG_variable
+  .byte 0                       # DW_CHILDREN_no
+  .byte 3                       # DW_AT_name
+  .byte 14                      # DW_FORM_strp
+  .byte 2                       # DW_AT_location
+  .byte 23                      # DW_FORM_sec_offset
+  .byte 0                       # EOM(1)
+  .byte 0                       # EOM(2)
+  .byte 0                       # EOM(3)
+
+  .section  .debug_info,"",@progbits
+.Lcu_begin0:
+  .long .Lcu_end0-.Lcu_start0   # Length of Unit
+.Lcu_start0:
+  .short  4                       # DWARF version number
+  .long .debug_abbrev           # Offset Into Abbrev. Section
+  .byte 8                       # Address Size (in bytes)
+  .byte 1                       # Abbrev [1] DW_TAG_compile_unit
+  .long .Linfo_producer         # DW_AT_producer
+  .byte 5                       # Abbrev [5] DW_TAG_variable
+  .long .Lname_a                # DW_AT_name
+  .long .Ldebug_loc0            # DW_AT_location
+  .byte 0                       # End Of Children Mark
+.Lcu_end0:

llvm/test/tools/llvm-dwarfdump/X86/debug_loc_OP_entry_value.s

+# RUN: llvm-mc -triple x86_64-pc-linux %s -filetype=obj | llvm-dwarfdump - | FileCheck %s
+#
+# CHECK: DW_TAG_variable
+# CHECK-NEXT: DW_AT_name ("a")
+# CHECK-NEXT: DW_AT_location
+# CHECK-NEXT: DW_OP_entry_value(DW_OP_reg5 RDI), DW_OP_stack_value)
+
+  .section  .debug_str,"MS",@progbits,1
+.Linfo_producer:
+  .asciz  "hand-written DWARF"
+.Lname_a:
+  .asciz  "a"
+
+  .section  .debug_loc,"",@progbits
+.Ldebug_loc0:
+  .quad 0
+  .quad 1
+  .short  .Lloc0_end-.Lloc0_start # Loc expr size
+.Lloc0_start:
+  .byte   163                     # DW_OP_entry_value
+  .byte 1                       # 1
+  .byte 85                      # super-register DW_OP_reg5
+  .byte 159                     # DW_OP_stack_value
+.Lloc0_end:
+  .quad 0
+  .quad 0
+  .section  .debug_abbrev,"",@progbits
+  .byte 1                       # Abbreviation Code
+  .byte 17                      # DW_TAG_compile_unit
+  .byte 1                       # DW_CHILDREN_yes
+  .byte 37                      # DW_AT_producer
+  .byte 14                      # DW_FORM_strp
+  .byte 0                       # EOM(1)
+  .byte 0                       # EOM(2)
+  .byte 5                       # Abbreviation Code
+  .byte 52                      # DW_TAG_variable
+  .byte 0                       # DW_CHILDREN_no
+  .byte 3                       # DW_AT_name
+  .byte 14                      # DW_FORM_strp
+  .byte 2                       # DW_AT_location
+  .byte 23                      # DW_FORM_sec_offset
+  .byte 0                       # EOM(1)
+  .byte 0                       # EOM(2)
+  .byte 0                       # EOM(3)
+
+  .section  .debug_info,"",@progbits
+.Lcu_begin0:
+  .long .Lcu_end0-.Lcu_start0   # Length of Unit
+.Lcu_start0:
+  .short  4                       # DWARF version number
+  .long .debug_abbrev           # Offset Into Abbrev. Section
+  .byte 8                       # Address Size (in bytes)
+  .byte 1                       # Abbrev [1] DW_TAG_compile_unit
+  .long .Linfo_producer         # DW_AT_producer
+  .byte 5                       # Abbrev [5] DW_TAG_variable
+  .long .Lname_a                # DW_AT_name
+  .long .Ldebug_loc0            # DW_AT_location
+  .byte 0                       # End Of Children Mark
+.Lcu_end0: