[DebugInfo] Add a DW_OP_LLVM_entry_value operation

[dstenb]

Summary

Internally in LLVM's metadata we use DW_OP_entry_value operations with
the same semantics as DWARF; that is, its operand specifies the number
of bytes that the entry value covers.

At the time of emitting entry values we don't know the emitted size of
the DWARF expression that the entry value will cover. Currently the size
is hardcoded to 1 in DIExpression, and other values causes the verifier
to fail. As the size is 1, that effectively means that we can only have
valid entry values for registers that can be encoded in one byte, which
are the registers with DWARF numbers 0 to 31 (as they can be encoded as
single-byte DW_OP_reg0..DW_OP_reg31 rather than a multi-byte
DW_OP_regx). It is a bit confusing, but it seems like llvm-dwarfdump
will print an operation "correctly", even if the byte size is less than
that, which may make it seem that we emit correct DWARF for registers
with DWARF numbers > 31. If you instead use readelf for such cases, it
will interpret the number of specified bytes as a DWARF expression. This
seems like a limitation in llvm-dwarfdump.

As suggested in D66746, a way forward would be to add an internal
variant of DW_OP_entry_value, DW_OP_LLVM_entry_value, whose operand
instead specifies the number of operations that the entry value covers,
and we then translate that into the byte size at the time of emission.

In this patch that internal operation is added. This patch keeps the
limitation that a entry value can only be applied to simple register
locations, but it will fix the issue with the size operand being
incorrect for DWARF numbers > 31.

[djtodoro]

@dstenb Thanks for this! This makes sense.

[aprantl]

Having suggested this, I think this is a good idea ;-)

llvm/docs/LangRef.rst

4784–4785

It's ambiguous where in the expression DW_OP_LLVM_entry_value can appear. Perhaps add an example or improve the wording? I assume it is still legal to combine a DW_OP_LLVM_entry_value with other operations?

4784–4785

not "DWARF expression" but in terms of std::distance of DIExpression operation iterators, right?

4785–4791

may appear -> is introduced by

4795

is also introduced by

llvm/lib/IR/DebugInfoMetadata.cpp

893–898

Can someone remind me what the reason for this limitation was again? Do we still need it after this patch?

[dstenb]

llvm/docs/LangRef.rst

4784–4785

In this patch DW_OP_LLVM_entry_value has the same semantics as the DWARF variant, so the operand still specifies the number of bytes.

llvm/lib/IR/DebugInfoMetadata.cpp

893–898

I think that the main (or perhaps only?) reason for this limitation is that we, at emission, currently don't have a good way to calculate the size of the block that the entry value covers, and emit that size as a ULEB128 operand before the block. This patch will not change that.

[aprantl]

Normally I would insist on a bitcode upgrade, but since this feature is so new I think we can skip that. However, because of bitcode compatability, we might want to get the semantics right from the start. Otherwise we might have to allocate a new opcode and implement an upgrade when we need to change it in the future.

llvm/lib/IR/DebugInfoMetadata.cpp

893–898

I see. Could you please add this to the comment here, so it's clear why the restriction exists and how to lift it in the future?

[djtodoro]

llvm/lib/IR/DebugInfoMetadata.cpp

893–898

I think that the main (or perhaps only?) reason for this limitation is that we, at emission, currently don't have a good way to calculate the size of the block that the entry value covers, and emit that size as a ULEB128 operand before the block.

We also wanted to ensure that LLVM currently only generates entry values of size 1.

[aprantl]

llvm/lib/IR/DebugInfoMetadata.cpp

893–898

Is there another reason for this other than that it happened to be hard to implement in LLVM at the time? Perhaps on the consumer side?

[djtodoro]

llvm/lib/IR/DebugInfoMetadata.cpp

893–898

Actually no. We found the simple register location as an entry value is very basic case (and easy to implement as the initial patch). We also knew that supporting the other types of entry values will take some time and we just left it as a future work.
The consumer (only GDB at the time) supports parsing various types of entry values.

[djtodoro]

llvm/lib/IR/DebugInfoMetadata.cpp

893–898

In addition to this, I work on extending the debug entry values to support complex expressions (more precisely, expressions other than simple register locations).

[vsk]

Looks reasonable to me, I just suggest clarifying one comment. @aprantl any other outstanding concerns?

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

714–716

-> "will contain 1 operation (e.g. a register op, or a constant literal)" ?

[dstenb]

llvm/lib/IR/DebugInfoMetadata.cpp

893–898

The consumer (only GDB at the time) supports parsing various types of entry values.

It seems like GDB only supports a few operations inside a DW_OP_entry_value. I have tried some examples with more advanced expressions, but then got hit with the following error from its expression evaluator:

DWARF-2 expression error: DW_OP_entry_value is supported only for single DW_OP_reg* or for DW_OP_breg*(0)+DW_OP_deref*

That error message seems present in GDB 8.3 at least. I might overlook something here though.

[dstenb]

llvm/lib/IR/DebugInfoMetadata.cpp

893–898

In addition to this, I work on extending the debug entry values to support complex expressions (more precisely, expressions other than simple register locations).

Oh, okay! Sorry, I have been working on adding support for DW_OP_regx entry values, by extending DwarfExpression so that it can count the size of the entry value block, and emit that size operand before the block itself. I guess that overlaps with the complex expressions a bit?

I uploaded a WIP patch for that: D67674.

Do you think that would be usable for your work?

[djtodoro]

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

714–716

Currently, we do not support expressions e.g. dw_op_entry_value $constant.

llvm/lib/IR/DebugInfoMetadata.cpp

893–898

It seems like GDB only supports a few operations inside a DW_OP_entry_value. I have tried some examples with more advanced expressions, but then got hit with the following error from its expression evaluator:

DWARF-2 expression error: DW_OP_entry_value is supported only for single DW_OP_reg* or for DW_OP_breg*(0)+DW_OP_deref*

That error message seems present in GDB 8.3 at least. I might overlook something here though.

You are right. Even GDB does not support every type of the debug entry value.

Oh, okay! Sorry, I have been working on adding support for DW_OP_regx entry values, by extending DwarfExpression so that it can count the size of the entry value block, and emit that size operand before the block itself. I guess that overlaps with the complex expressions a bit?

I uploaded a WIP patch for that: D67674.

Do you think that would be usable for your work?

No problem. :) Please continue with this work, I will focus on reconstructing debug values of modified parameters (and local variables) that can be expressed in terms of the debug entry values (e.g. dw_op_entry_value dw_op_reg; dw_op_plus const).

[dstenb]

Update patch after comments, and change the semantics of the new operation. Rather than only introducing an internal variant that has the same behavior as DW_OP_entry_value, the new operation's operand specifies the number of operations (including the value/address operand) that are covered by the entry value, and that value is then converted to the byte size when we emit the entry value in DwarfExpression.

To keep the changes reasonably large, this patch keeps the limitation that the operand can only be set to one, and entry values still only works for register debug values. To support DW_OP_LLVM_entry_values covering more than one operation, you would need to add more finalizeEntryValue logic to DwarfExpression.

I opted for the operand describing the number of operations that the entry values cover, rather than the std::distance in the DIExpression, under the assumption that this will make it slightly cleaner to implement things. I can change it to std::distance though if that is preferred.

To make the patch reasonably small and reviewable I split the code that adds the ability to count the size of the DWARF block in DwarfExpression into a parent patch.

[aprantl]

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

7

This is testing that *any* of these expressions are malformed. You either want a more specific CHECK line or more tests.

[dstenb]

Make the diexpression-entry-value.ll test case FileCheck all DIExpressions.

[dstenb]

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

7

Yes, thanks! I added checks for all three DIExpressions now.

[djtodoro]

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

5

I am just curious. Having the D67768, do we really still need the size of following expression at this point?

[dstenb]

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

5

I guess that the size operand is currently redundant, and we can omit it. However, I have made the assumption that specifying the size will simplify things when we get to describing more complex variables like local in the example below using entry values:

int foo(int param) {
  int local = param + 1;
  use_of_param = param;
  clobber();
  return 0;
}

Here local will have the entry value of $edi + 1. GDB will not understand a DW_OP_entry_value whose block is that complex, so I imagine that we want to emit the same expression as GCC:

(DW_OP_entry_value: (DW_OP_reg5 (rdi)); DW_OP_plus_uconst: 1; DW_OP_stack_value)

I guess that the DW_OP_LLVM_entry_value operation could cover the whole expression in the DIExpression world, and we then wrap only the parts that actually needs to be covered by entry values when we lower that to DW_OP_entry_value in DwarfExpression. However, I'm a bit afraid that that would further complicate the DwarfExpression state machine, which is already quite complex.

Looking further onwards, I guess that we want to transform the current dbg.value/DBG_VALUE/DIExpression framework to something that allows us to describe a variable using multiple register / memory values. For example, like local in the example below:

int bar(int a, int b) {
  int local = a + b;
  [...]
}

I assume that we want to be able to describe such variables using entry values for only a subset of the registers. GCC is able to emit such expressions. I guess that having a DW_OP_LLVM_entry_value operation that only applies for a part of an DIExpression will be helpful when we get there, but that's pure speculation as I don't know how the debug framework will look.

[aprantl]

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

5

IMO, we should make the IR support as generic as possible and accept more complex uses of DW_OP_LLVM_entry_value that LLVM currently cannot produce itself and generate the correct DWARF for it.

In order to generate that particular example though, it might be useful to add another operand (let's call it DW_OP_LLVM_dbg_value) to make the implicit first operand explicit, so this could be

!DIExpression(DW_OP_LLVM_entry_value, 1, DW_OP_LLVM_dbg_value, DW_OP_plus, DW_OP_uconst, 1, DW_OP_stack_value).

and the backend substitutes DW_OP_breg5 for DW_OP_dbg_value. In the future, we could further generalize llvm.dbg.value to take extra arguments that would show up as DW_OP_LLVM_dbg_value_[0-9]+ to allow binding more than one SSA value to a DIExpression.

[aprantl]

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

5

(and of course to confuse everybody I accidentally flipped the order of DW_OP_plus and DW_OP_uconst in my example...)

[djtodoro]

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

5

Here local will have the entry value of $edi + 1. GDB will not understand a DW_OP_entry_value whose block is that complex, so I imagine that we want to emit the same expression as GCC:

Sure. Not only local variables, I am currently extending the LiveDebugValues to support such scenario when parameters are part of such expression and I will share that in the following days. Let's keep it for now.

Let me say something about extending the llvm.dbg.value, I already got similar idea to extend the salvageDebugInfo() functionality when we are removing an instruction operating on two registers (rather then reg and constant), so I think that having that type of instruction will give us a lot of benefits, not only in situations like that. :)

[djtodoro]

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

5

I guess that the DW_OP_LLVM_entry_value operation could cover the whole expression in the DIExpression world, and we then wrap only the parts that actually needs to be covered by entry values when we lower that to DW_OP_entry_value in DwarfExpression. However, I'm a bit afraid that that would further complicate the DwarfExpression state machine, which is already quite complex.

Having this pre-calculation interface at this point for entry values expressions won't be desirable for situations where entry value is just part of complex expression like you described, since that the DwarfExpression won't be able to distinguish what is entry value part and what is the rest of the complex expression (e.g. (DW_OP_entry_value: (DW_OP_reg5 (rdi)); DW_OP_plus_uconst: 1; DW_OP_stack_value) where the DIExpression would look as DIExpression(DW_OP_LLVM_entry_value, 1, DW_OP_plus_uconst, 1, DW_OP_stack_value)).
I think it would be ideally if we were to somehow create the right size operand from the entry value DIExpression when the entry value gets created during the LiveDebugValues (we agree that it is very hard, or even impossible), but we would know what part of a complex expression is the "entry value" part and what part is not. Therefore, in the current situation I don't think that the size operand (from entry value DIExpresion) has any impact on simplifying the support for the complex expressions like we described. In that situation we should just see if the DIExpression contains any additional DWARF operands and mark it as "non-entry value" part and somehow make another buffer for that until the entry value part gets printed via current interface.

[dstenb]

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

5

won't be able to distinguish what is entry value part and what is the rest of the complex expression

I think that is possible with this semantics. In this patch the operand specifies that the value operand and the (N - 1) number of operations are covered by the entry value, so for N > 1 shouldn't we be able to finish the entry value after emitting those remaining (N - 1) operations in DwarfExpression::addExpression()?

In your example N is 1, so we should only emit the entry value around the register. I think we need to modify the current implementation of DwarfExpression::addMachineRegExpression() a bit so that it emits a DW_OP_regx rather than taking the code path where the expression is optimized into a DW_OP_breg $reg, 1 [0]. We also need to make sure that the DW_OP_stack_value is emitted at the end of the whole expression, rather than after the entry value, which is currently done [1]. I think that with those changes it should be possible to emit your example using the semantics that this patch introduces, at the risk of overlooking some other issue.

I still haven't been able to think of an example where the DW_OP_LLVM_entry_value's size operand being larger than 1 would actually be useful though.

[0] https://github.com/llvm/llvm-project/blob/master/llvm/lib/CodeGen/AsmPrinter/DwarfExpression.cpp#L249
[1] https://github.com/llvm/llvm-project/blob/master/llvm/lib/CodeGen/AsmPrinter/DwarfExpression.cpp#L258

[dstenb]

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

5

Perhaps something along the lines of this: D68034. The location kind handling likely needs more thought though.

[djtodoro]

This looks good to me, thanks!

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

5

I have not switched my self to the new semantics yet.. I see, this makes sense then :)

[dstenb]

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

5

Okay! I have hopefully not oversimplified what it what it would take to handle the expressions in DwarfExpression, but I at least think that it should be doable.

[dstenb]

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

5

Adding something like a DW_OP_LLVM_dbg_value, which makes the entry value's use of the value operand explicit, sounds reasonable, @aprantl! As I assume that that is a rather large change, which needs to be further fleshed out, could we perhaps consider introducing this patch's semantics as an intermediate step? When a DW_OP_LLVM_dbg_value is later on introduced, I assume that the bitcode reader would be able to upgrade the metadata by inserting such operations after the DW_OP_LLVM_entry_values to make the use of the value operand explicit?

[aprantl]

llvm/docs/LangRef.rst

4785–4791

The documentation currently doesn't make clear whether DW_OP_LLVM_entry_value considers the implicit SSA value bound by a dbg.value / the argument of a DBG_VALUE to be part of the entry value or the surrounding expression and/or whether it expects a hardcoded location such as DW_OP_breg0 inside the DW_OP_LLVM_entry_value. It also isn't clear whether DW_OP_LLVM_entry_value is only legal in MIR, or also in LLVM IR and what the semantics in LLVM IR are if it is allowed.

I think a few examples would go a long way here.

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

5

Yes that should be a separate discussion. We need to make clear what the semantics without this addition are though. See my comment in LangRef above.

[dstenb]

Update LangRef.

[dstenb]

llvm/docs/LangRef.rst

4785–4791

I have now updated the text to hopefully make it more descriptive.

I have updated the documentation to say that the operation is only legal in MIR, mainly as the operation has not been tested in LLVM IR, and I personally don't see why anyone would want to emit it there. Any comments on that, @djtodoro and @NikolaPrica?

[aprantl]

llvm/docs/LangRef.rst

4795

Thanks, this is more clear now! The fact that this is only legal in MIR also absolves us from bitcode compatibility issues. Can you add a verifier checks that asserts that no DbgInfoInstrinsic references a DIExpression with this opcode to make sure it's illegal in LLVM IR? This way we'll be free to experiment as much as we want with the semantics of this operator.

[djtodoro]

llvm/docs/LangRef.rst

4785–4791

This looks nice! Thanks!

If we face situation where the entry value operation is useful for the LLVM IR we can revisit this, but at the moment I can not imagine such situation.

[dstenb]

Add IR verifier check.

[dstenb]

Any more comments on this or D67768?

[aprantl]

llvm/lib/IR/Verifier.cpp

5024 ↗

(On Diff #222620)

"only allowed in MIR" is perhaps more helpful.

[dstenb]

Thanks for the reviews! I'll merge this shortly.

llvm/lib/IR/Verifier.cpp

5024 ↗

(On Diff #222620)

Yes, that's more helpful. I'll update that.

llvm/docs/LangRef.rst

- ``DW_OP_LLVM_convert, 16, DW_ATE_signed`` specifies a bit size and encoding
   that references a base type constructed from the supplied values.
 - ``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.
+- ``DW_OP_LLVM_entry_value, N`` specifies that all register and memory read
+  operations in the value/address operand and in the ``(N - 1)`` operations
+  immediately following the ``DW_OP_LLVM_entry_value`` refer to their
+  respective values at function entry. ``DW_OP_LLVM_entry_value`` must appear
+  in the beginning of the DIExpression. Due to framework limitations ``N`` can
+  currently only be 1.
+  ``DW_OP_LLVM_entry_value`` is introduced by 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
+  ``DW_OP_LLVM_entry_value`` is also introduced by the ``AsmPrinter`` pass when
   a call site parameter value (``DW_AT_call_site_parameter_value``)
   is represented as entry value of the parameter.
 - ``DW_OP_breg`` (or ``DW_OP_bregx``) represents a content on the provided
   signed offset of the specified register. The opcode is only generated by the
   ``AsmPrinter`` pass to describe call site parameter value which requires an
   expression over two registers.
 
 DWARF specifies three kinds of simple location descriptions: Register, memory,

 
 DIFlags
 """""""""""""""
 
 These flags encode various properties of DINodes.
 
 The `ArgumentNotModified` flag marks a function argument whose value
 is not modified throughout of a function. This flag is used to decide
-whether a DW_OP_entry_value can be used in a location description
+whether a DW_OP_LLVM_entry_value can be used in a location description
 after the function prologue. The language frontend is expected to compute
 this property for each DILocalVariable. The flag should be used
 only in optimized code.
 
 The `ExportSymbols` flag marks a class, struct or union whose members
 may be referenced as if they were defined in the containing class or
 union. This flag is used to decide whether the DW_AT_export_symbols can
 be used for the structure type.

llvm/include/llvm/BinaryFormat/Dwarf.h

#include "llvm/BinaryFormat/Dwarf.def"
   DW_FORM_lo_user = 0x1f00, ///< Not specified by DWARF.
 };
 
 enum LocationAtom {
 #define HANDLE_DW_OP(ID, NAME, VERSION, VENDOR) DW_OP_##NAME = ID,
 #include "llvm/BinaryFormat/Dwarf.def"
   DW_OP_lo_user = 0xe0,
   DW_OP_hi_user = 0xff,
-  DW_OP_LLVM_fragment = 0x1000,   ///< Only used in LLVM metadata.
-  DW_OP_LLVM_convert = 0x1001,    ///< Only used in LLVM metadata.
-  DW_OP_LLVM_tag_offset = 0x1002, ///< Only used in LLVM metadata.
+  DW_OP_LLVM_fragment = 0x1000,    ///< Only used in LLVM metadata.
+  DW_OP_LLVM_convert = 0x1001,     ///< Only used in LLVM metadata.
+  DW_OP_LLVM_tag_offset = 0x1002,  ///< Only used in LLVM metadata.
+  DW_OP_LLVM_entry_value = 0x1003, ///< Only used in LLVM metadata.
 };
 
 enum TypeKind : uint8_t {
 #define HANDLE_DW_ATE(ID, NAME, VERSION, VENDOR) DW_ATE_##NAME = ID,
 #include "llvm/BinaryFormat/Dwarf.def"
   DW_ATE_lo_user = 0x80,
   DW_ATE_hi_user = 0xff
 };

llvm/include/llvm/CodeGen/MachineInstr.h

public:
   /// the second operand is an immediate.
   bool isIndirectDebugValue() const {
     return isDebugValue()
       && getOperand(0).isReg()
       && getOperand(1).isImm();
   }
 
   /// A DBG_VALUE is an entry value iff its debug expression contains the
-  /// DW_OP_entry_value DWARF operation.
+  /// DW_OP_LLVM_entry_value operation.
   bool isDebugEntryValue() const {
     return isDebugValue() && getDebugExpression()->isEntryValue();
   }
 
   /// Return true if the instruction is a debug value which describes a part of
   /// a variable as unavailable.
   bool isUndefDebugValue() const {
     return isDebugValue() && getOperand(0).isReg() && !getOperand(0).getReg().isValid();

llvm/include/llvm/IR/DebugInfoMetadata.h

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;
+           getElement(0) == dwarf::DW_OP_LLVM_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/BinaryFormat/Dwarf.cpp

case DW_OP_##NAME:                                                           \
     return "DW_OP_" #NAME;
 #include "llvm/BinaryFormat/Dwarf.def"
   case DW_OP_LLVM_convert:
     return "DW_OP_LLVM_convert";
   case DW_OP_LLVM_fragment:
     return "DW_OP_LLVM_fragment";
   case DW_OP_LLVM_tag_offset:
     return "DW_OP_LLVM_tag_offset";
+  case DW_OP_LLVM_entry_value:
+    return "DW_OP_LLVM_entry_value";
   }
 }
 
 unsigned llvm::dwarf::getOperationEncoding(StringRef OperationEncodingString) {
   return StringSwitch<unsigned>(OperationEncodingString)
 #define HANDLE_DW_OP(ID, NAME, VERSION, VENDOR)                                \
   .Case("DW_OP_" #NAME, DW_OP_##NAME)
 #include "llvm/BinaryFormat/Dwarf.def"
       .Case("DW_OP_LLVM_convert", DW_OP_LLVM_convert)
       .Case("DW_OP_LLVM_fragment", DW_OP_LLVM_fragment)
       .Case("DW_OP_LLVM_tag_offset", DW_OP_LLVM_tag_offset)
+      .Case("DW_OP_LLVM_entry_value", DW_OP_LLVM_entry_value)
       .Default(0);
 }
 
 unsigned llvm::dwarf::OperationVersion(dwarf::LocationAtom Op) {
   switch (Op) {
   default:
     return 0;
 #define HANDLE_DW_OP(ID, NAME, VERSION, VENDOR)                                \

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 Register isDescribedByReg(const MachineInstr &MI) {
   assert(MI.isDebugValue());
   assert(MI.getNumOperands() == 4);
-  // If the location of variable is an entry value (DW_OP_entry_value)
+  // If the location of variable is an entry value (DW_OP_LLVM_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() : Register();
 }
 

llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

void DwarfCompileUnit::addComplexAddress(const DbgVariable &DV, DIE &Die,
   DwarfExpr.addFragmentOffset(DIExpr);
   if (Location.isIndirect())
     DwarfExpr.setMemoryLocationKind();
 
   DIExpressionCursor Cursor(DIExpr);
 
   if (DIExpr->isEntryValue()) {
     DwarfExpr.setEntryValueFlag();
-    DwarfExpr.addEntryValueExpression(Cursor);
+    DwarfExpr.beginEntryValueExpression(Cursor);
   }
 
   const TargetRegisterInfo &TRI = *Asm->MF->getSubtarget().getRegisterInfo();
   if (!DwarfExpr.addMachineRegExpression(TRI, Cursor, Location.getReg()))
     return;
   DwarfExpr.addExpression(std::move(Cursor));
 
   // Now attach the location information to the DIE.

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

if (auto ParamValue = TII->describeLoadedValue(*I)) {
           RegsForEntryValues[RegLoc] = Reg;
         }
       }
     }
   }
 
   // Emit the call site parameter's value as an entry value.
   if (ShouldTryEmitEntryVals) {
-    // Create an entry value expression where the expression following
-    // the 'DW_OP_entry_value' will be the size of 1 (a register operation).
-    DIExpression *EntryExpr = DIExpression::get(MF->getFunction().getContext(),
-                                                {dwarf::DW_OP_entry_value, 1});
+    // Create an expression where the register's entry value is used.
+    DIExpression *EntryExpr = DIExpression::get(
+        MF->getFunction().getContext(), {dwarf::DW_OP_LLVM_entry_value, 1});
     for (auto RegEntry : ForwardedRegWorklist) {
       unsigned FwdReg = RegEntry;
       auto EntryValReg = RegsForEntryValues.find(RegEntry);
         if (EntryValReg != RegsForEntryValues.end())
           FwdReg = EntryValReg->second;
 
       DbgValueLoc DbgLocVal(EntryExpr, MachineLocation(RegEntry));
       DbgCallSiteParam CSParm(FwdReg, DbgLocVal);
void DwarfDebug::emitDebugLocValue(const AsmPrinter &AP, const DIBasicType *BT,
   } else if (Value.isLocation()) {
     MachineLocation Location = Value.getLoc();
     if (Location.isIndirect())
       DwarfExpr.setMemoryLocationKind();
     DIExpressionCursor Cursor(DIExpr);
 
     if (DIExpr->isEntryValue()) {
       DwarfExpr.setEntryValueFlag();
-      DwarfExpr.addEntryValueExpression(Cursor);
+      DwarfExpr.beginEntryValueExpression(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();

llvm/lib/CodeGen/AsmPrinter/DwarfExpression.h

 protected:
   /// Holds information about all subregisters comprising a register location.
   struct Register {
     int DwarfRegNo;
     unsigned Size;
     const char *Comment;
   };
 
+  /// Whether we are currently emitting an entry value operation.
+  bool IsEmittingEntryValue = false;
+
   DwarfCompileUnit &CU;
 
   /// The register location, if any.
   SmallVector<Register, 2> DwarfRegs;
 
   /// Current Fragment Offset in Bits.
   uint64_t OffsetInBits = 0;
 
protected:
   /// DWARF 2 and DWARF 3. Technically, this is incorrect since DW_OP_const
   /// <const> actually describes a value at a constant address, not a constant
   /// value.  However, in the past there was no better way to describe a
   /// constant value, so the producers and consumers started to rely on
   /// heuristics to disambiguate the value vs. location status of the
   /// expression.  See PR21176 for more details.
   void addStackValue();
 
+  /// Finalize an entry value by emitting its size operand, and committing the
+  /// DWARF block which has been emitted to the temporary buffer.
+  void finalizeEntryValue();
+
   ~DwarfExpression() = default;
 
 public:
   DwarfExpression(unsigned DwarfVersion, DwarfCompileUnit &CU)
       : CU(CU), SubRegisterSizeInBits(0), SubRegisterOffsetInBits(0),
         LocationKind(Unknown), LocationFlags(Unknown),
         DwarfVersion(DwarfVersion) {}
 
public:
   ///                                 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);
+  /// Begin emission of an entry value dwarf operation. The entry value's
+  /// first operand is the size of the DWARF block (its second operand),
+  /// which needs to be calculated at time of emission, so we don't emit
+  /// any operands here.
+  void beginEntryValueExpression(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,
   if (!isMemoryLocation() && !HasComplexExpression && (!isParameterValue() ||
                                                        isEntryValue())) {
     for (auto &Reg : DwarfRegs) {
       if (Reg.DwarfRegNo >= 0)
         addReg(Reg.DwarfRegNo, Reg.Comment);
       addOpPiece(Reg.Size);
     }
 
+    if (isEntryValue())
+      finalizeEntryValue();
+
     if (isEntryValue() && !isParameterValue() && 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.
bool DwarfExpression::addMachineRegExpression(const TargetRegisterInfo &TRI,
   if (FBReg)
     addFBReg(SignedOffset);
   else
     addBReg(Reg.DwarfRegNo, SignedOffset);
   DwarfRegs.clear();
   return true;
 }
 
-void DwarfExpression::addEntryValueExpression(DIExpressionCursor &ExprCursor) {
+void DwarfExpression::beginEntryValueExpression(
+    DIExpressionCursor &ExprCursor) {
   auto Op = ExprCursor.take();
-  assert(Op && Op->getOp() == dwarf::DW_OP_entry_value);
+  assert(Op && Op->getOp() == dwarf::DW_OP_LLVM_entry_value);
   assert(!isMemoryLocation() &&
          "We don't support entry values of memory locations yet");
+  assert(!IsEmittingEntryValue && "Already emitting entry value?");
+  assert(Op->getArg(0) == 1 &&
+         "Can currently only emit entry values covering a single operation");
 
   emitOp(CU.getDwarf5OrGNULocationAtom(dwarf::DW_OP_entry_value));
-  emitUnsigned(Op->getArg(0));
+  IsEmittingEntryValue = true;
+  enableTemporaryBuffer();
+}
+
+void DwarfExpression::finalizeEntryValue() {
+  assert(IsEmittingEntryValue && "Entry value not open?");
+  disableTemporaryBuffer();
+
+  // Emit the entry value's size operand.
+  unsigned Size = getTemporaryBufferSize();
+  emitUnsigned(Size);
+
+  // Emit the entry value's DWARF block operand.
+  commitTemporaryBuffer();
+
+  IsEmittingEntryValue = false;
 }
 
 /// 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:

llvm/lib/IR/DebugInfoMetadata.cpp

unsigned DIExpression::ExprOperand::getSize() const {
   case dwarf::DW_OP_LLVM_fragment:
   case dwarf::DW_OP_bregx:
     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_entry_value:
+  case dwarf::DW_OP_LLVM_entry_value:
   case dwarf::DW_OP_regx:
     return 2;
   default:
     return 1;
   }
 }
 
 bool DIExpression::isValid() const {
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.
+    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_convert:
     case dwarf::DW_OP_LLVM_tag_offset:
     case dwarf::DW_OP_constu:
     case dwarf::DW_OP_plus_uconst:
     case dwarf::DW_OP_plus:

 
 DIExpression *DIExpression::prependOpcodes(const DIExpression *Expr,
                                            SmallVectorImpl<uint64_t> &Ops,
                                            bool StackValue,
                                            bool EntryValue) {
   assert(Expr && "Can't prepend ops to this expression");
 
   if (EntryValue) {
-    Ops.push_back(dwarf::DW_OP_entry_value);
+    Ops.push_back(dwarf::DW_OP_LLVM_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;

llvm/test/DebugInfo/ARM/entry-value-multi-byte-expr.ll

+; RUN: llc -debug-entry-values -filetype=asm -o - %s | FileCheck %s
+
+; Verify that the size operands of the DW_OP_GNU_entry_value operations are
+; correct for the multi-byte DW_OP_regx expressions.
+
+; Based on the following C reproducer:
+;
+; extern void clobber();
+; double global;
+; int f(double a, double b) {
+;   global = a + b;
+;   clobber();
+;   return 1;
+; }
+
+; This test checks the assembly output rather than the output from
+; llvm-dwarfdump, as the latter printed the DW_OP_regx D0 correctly, even
+; though the entry value's size operand did not fully cover that:
+
+; DW_OP_GNU_entry_value(DW_OP_regx D0), DW_OP_stack_value
+;
+; whereas readelf interpreted it as an DW_OP_GNU_entry_value covering one byte,
+; resulting in garbage data:
+;
+; DW_OP_GNU_entry_value: (DW_OP_regx: 0 (r0)); DW_OP_breg16 (r16): 2; DW_OP_stack_value
+
+; CHECK:      .byte   243       @ DW_OP_GNU_entry_value
+; CHECK-NEXT: .byte   3         @ 3
+; CHECK-NEXT: .byte   144       @ DW_OP_regx
+; CHECK-NEXT: .byte   128       @ 256
+; CHECK-NEXT: .byte   2         @
+; CHECK-NEXT: .byte   159       @ DW_OP_stack_value
+
+; CHECK:      .byte   243       @ DW_OP_GNU_entry_value
+; CHECK-NEXT: .byte   3         @ 3
+; CHECK-NEXT: .byte   144       @ DW_OP_regx
+; CHECK-NEXT: .byte   129       @ 257
+; CHECK-NEXT: .byte   2         @
+; CHECK-NEXT: .byte   159       @ DW_OP_stack_value
+
+target datalayout = "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64"
+target triple = "armv7-unknown-unknown"
+
+@global = common global double 0.000000e+00, align 8, !dbg !0
+
+; Function Attrs: nounwind
+define arm_aapcs_vfpcc i32 @f(double %a, double %b) #0 !dbg !12 {
+entry:
+  call void @llvm.dbg.value(metadata double %a, metadata !17, metadata !DIExpression()), !dbg !19
+  call void @llvm.dbg.value(metadata double %b, metadata !18, metadata !DIExpression()), !dbg !19
+  %add = fadd double %a, %b, !dbg !20
+  store double %add, double* @global, align 8, !dbg !20
+  tail call arm_aapcs_vfpcc void @clobber(), !dbg !21
+  ret i32 1, !dbg !22
+}
+
+declare arm_aapcs_vfpcc void @clobber()
+
+; Function Attrs: nounwind readnone speculatable willreturn
+declare void @llvm.dbg.value(metadata, metadata, metadata) #1
+
+attributes #0 = { nounwind }
+attributes #1 = { nounwind readnone speculatable willreturn }
+
+!llvm.dbg.cu = !{!2}
+!llvm.module.flags = !{!7, !8, !9, !10}
+!llvm.ident = !{!11}
+
+!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+!1 = distinct !DIGlobalVariable(name: "global", scope: !2, file: !3, line: 4, type: !6, isLocal: false, isDefinition: true)
+!2 = distinct !DICompileUnit(language: DW_LANG_C99, file: !3, producer: "clang version 10.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !5, nameTableKind: None)
+!3 = !DIFile(filename: "entry-value-multi-byte-expr.c", directory: "/")
+!4 = !{}
+!5 = !{!0}
+!6 = !DIBasicType(name: "double", size: 64, encoding: DW_ATE_float)
+!7 = !{i32 2, !"Dwarf Version", i32 4}
+!8 = !{i32 2, !"Debug Info Version", i32 3}
+!9 = !{i32 1, !"wchar_size", i32 4}
+!10 = !{i32 1, !"min_enum_size", i32 4}
+!11 = !{!"clang version 10.0.0"}
+!12 = distinct !DISubprogram(name: "f", scope: !3, file: !3, line: 6, type: !13, scopeLine: 6, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !2, retainedNodes: !16)
+!13 = !DISubroutineType(types: !14)
+!14 = !{!15, !6, !6}
+!15 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!16 = !{!17, !18}
+!17 = !DILocalVariable(name: "a", arg: 1, scope: !12, file: !3, line: 6, type: !6, flags: DIFlagArgumentNotModified)
+!18 = !DILocalVariable(name: "b", arg: 2, scope: !12, file: !3, line: 6, type: !6, flags: DIFlagArgumentNotModified)
+!19 = !DILocation(line: 0, scope: !12)
+!20 = !DILocation(line: 7, scope: !12)
+!21 = !DILocation(line: 8, scope: !12)
+!22 = !DILocation(line: 9, scope: !12)

llvm/test/DebugInfo/MIR/Hexagon/live-debug-values-bundled-entry-values.mir

 
 ...
 
 # CHECK-LABEL: name: foo
 # CHECK: BUNDLE
 # CHECK-NEXT: $r29 = S2_allocframe $r29, 0
 # CHECK-NEXT: J2_call @clobber
 # CHECK-NEXT: }
-# CHECK-NEXT: DBG_VALUE $r0, $noreg, !16, !DIExpression(DW_OP_entry_value, 1)
+# CHECK-NEXT: DBG_VALUE $r0, $noreg, !16, !DIExpression(DW_OP_LLVM_entry_value, 1)
 
 ---
 name:            bar
 tracksRegLiveness: true
 liveins:
   - { reg: '$r0' }
 body:             |
   bb.0.entry:

 ...
 
 # CHECK-LABEL: name: bar
 # CHECK: BUNDLE
 # CHECK: BUNDLE
 # CHECK-NEXT: $r29 = S2_allocframe $r29, 0
 # CHECK-NEXT: J2_call @clobber
 # CHECK-NEXT: }
-# CHECK-NEXT: DBG_VALUE $r0, $noreg, !22, !DIExpression(DW_OP_entry_value, 1)
+# CHECK-NEXT: DBG_VALUE $r0, $noreg, !22, !DIExpression(DW_OP_LLVM_entry_value, 1)

llvm/test/DebugInfo/MIR/X86/avoid-single-entry-value-location.mir

 tracksRegLiveness: true
 body:             |
   bb.0.entry:
   liveins: $rdi
     DBG_VALUE $rdi, $noreg, !16, !DIExpression(), debug-location !18
     DBG_VALUE $edi, $noreg, !16, !DIExpression(), debug-location !18
     DBG_VALUE $edi, $noreg, !17, !DIExpression(), debug-location !18
     $edi = KILL renamable $edi, implicit killed $rdi, debug-location !18
-    DBG_VALUE $rdi, $noreg, !16, !DIExpression(DW_OP_entry_value, 1), debug-location !18
+    DBG_VALUE $rdi, $noreg, !16, !DIExpression(DW_OP_LLVM_entry_value, 1), debug-location !18
     TAILJMPd64 @fn2, csr_64, implicit $rsp, implicit $ssp, implicit $rsp, implicit $ssp, implicit killed $edi, debug-location !18
 
 ...

llvm/test/DebugInfo/MIR/X86/dbgcall-site-interpretation.mir

bb.0.entry:
     CALL64pcrel32 @foo, csr_64, implicit $rsp, implicit $ssp, implicit $edi, implicit $esi, implicit $rdx, implicit $ecx, implicit-def $rsp, implicit-def $ssp, implicit-def $eax, implicit-def $rax, debug-location !21
     DBG_VALUE $eax, $noreg, !14, !DIExpression(), debug-location !21
     renamable $eax = nsw ADD32ri8 killed renamable $eax, 4, implicit-def dead $eflags, debug-location !21
     $rsp = frame-destroy ADD64ri8 $rsp, 16, implicit-def dead $eflags, debug-location !21
     CFI_INSTRUCTION def_cfa_offset 32, debug-location !21
     $rbx = frame-destroy POP64r implicit-def $rsp, implicit $rsp, debug-location !21
     CFI_INSTRUCTION def_cfa_offset 24, debug-location !21
     $r14 = frame-destroy POP64r implicit-def $rsp, implicit $rsp, debug-location !21
-    DBG_VALUE $ecx, $noreg, !17, !DIExpression(DW_OP_entry_value, 1), debug-location !21
+    DBG_VALUE $ecx, $noreg, !17, !DIExpression(DW_OP_LLVM_entry_value, 1), debug-location !21
     CFI_INSTRUCTION def_cfa_offset 16, debug-location !21
     $r15 = frame-destroy POP64r implicit-def $rsp, implicit $rsp, debug-location !21
-    DBG_VALUE $esi, $noreg, !15, !DIExpression(DW_OP_entry_value, 1), debug-location !21
+    DBG_VALUE $esi, $noreg, !15, !DIExpression(DW_OP_LLVM_entry_value, 1), debug-location !21
     CFI_INSTRUCTION def_cfa_offset 8, debug-location !21
     RETQ $eax, debug-location !21
 
 ...

llvm/test/DebugInfo/MIR/X86/dbginfo-entryvals.mir

 # RUN: llc -debug-entry-values -run-pass=livedebugvalues -march=x86-64 -o - %s | FileCheck %s
 #
 #extern void fn2(int);
 #
 #__attribute__((noinline))
 #void
 #fn1 (int x, int y) {
 #  int u = x + y;
 #  if (x > 1)
 #    u += 1;
 #  else
 #    u += 2;
 #  int a = 7;
 #  fn2 (a);
 #  u --;
 #}
-# CHECK: DBG_VALUE $edi, $noreg, !14, !DIExpression(DW_OP_entry_value, 1), debug-location {{.*}}
-# CHECK: DBG_VALUE $esi, $noreg, !15, !DIExpression(DW_OP_entry_value, 1), debug-location {{.*}}
+# CHECK: DBG_VALUE $edi, $noreg, !14, !DIExpression(DW_OP_LLVM_entry_value, 1), debug-location {{.*}}
+# CHECK: DBG_VALUE $esi, $noreg, !15, !DIExpression(DW_OP_LLVM_entry_value, 1), debug-location {{.*}}
 
 --- |
   ; ModuleID = 'test.c'
   source_filename = "test.c"
   target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
   
   ; Function Attrs: noinline nounwind uwtable
   define dso_local void @fn1(i32 %x, i32 %y) local_unnamed_addr !dbg !9 {

llvm/test/DebugInfo/MIR/X86/multiple-param-dbg-value-entry.mir

 # RUN: llc -debug-entry-values -run-pass=livedebugvalues -march=x86-64 -o - %s| FileCheck %s
 #
 #int global;
 #int foo(int p, int q, int r) {
 #  global = p + 1;
 #  asm __volatile("" : : : "edi", "esi", "edx");
 #  return 123;
 #}
 #
-# Verify that DW_OP_entry_values are generated for parameters with multiple
+# Verify that DW_OP_LLVM_entry_values are generated for parameters with multiple
 # DBG_VALUEs at entry block.
-# CHECK: DBG_VALUE $edi, $noreg, !{{.*}}, !DIExpression(DW_OP_entry_value, 1), debug-location {{.*}}
-# CHECK: DBG_VALUE $edx, $noreg, !{{.*}}, !DIExpression(DW_OP_entry_value, 1), debug-location {{.*}}
-# CHECK: DBG_VALUE $esi, $noreg, !{{.*}}, !DIExpression(DW_OP_entry_value, 1), debug-location {{.*}}
+# CHECK: DBG_VALUE $edi, $noreg, !{{.*}}, !DIExpression(DW_OP_LLVM_entry_value, 1), debug-location {{.*}}
+# CHECK: DBG_VALUE $edx, $noreg, !{{.*}}, !DIExpression(DW_OP_LLVM_entry_value, 1), debug-location {{.*}}
+# CHECK: DBG_VALUE $esi, $noreg, !{{.*}}, !DIExpression(DW_OP_LLVM_entry_value, 1), debug-location {{.*}}
 
 --- |
   ; ModuleID = 'multiple-param-dbg-value-entry.ll'
   source_filename = "multiple-param-dbg-value-entry.c"
   target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
   @global = common dso_local local_unnamed_addr global i32 0, align 4, !dbg !0
 

llvm/test/DebugInfo/Sparc/entry-value-complex-reg-expr.ll

+; RUN: llc -debug-entry-values -filetype=asm -o - %s | FileCheck %s
+
+; Verify that the entry value covers both of the DW_OP_regx pieces. Previously
+; the size operand of the entry value would be hardcoded to one.
+;
+; XXX: Is this really what should be emitted, or should we instead emit one
+; entry value operation per DW_OP_regx? GDB can currently not understand
+; entry values containing complex expressions like this.
+
+target datalayout = "E-m:e-i64:64-n32:64-S128"
+target triple = "sparc64"
+
+; Based on the following C reproducer:
+;
+; volatile long double global;
+; extern void clobber();
+; int foo(long double p) {
+;   global = p;
+;   clobber();
+;   return 123;
+; }
+
+; CHECK:      .byte   243       ! DW_OP_GNU_entry_value
+; CHECK-NEXT: .byte   8         ! 8
+; CHECK-NEXT: .byte   144       ! sub-register DW_OP_regx
+; CHECK-NEXT: .byte   72        ! 72
+; CHECK-NEXT: .byte   147       ! DW_OP_piece
+; CHECK-NEXT: .byte   8         ! 8
+; CHECK-NEXT: .byte   144       ! sub-register DW_OP_regx
+; CHECK-NEXT: .byte   73        ! 73
+; CHECK-NEXT: .byte   147       ! DW_OP_piece
+; CHECK-NEXT: .byte   8         ! 8
+; CHECK-NEXT: .byte   159       ! DW_OP_stack_value
+
+@global = common global fp128 0xL00000000000000000000000000000000, align 16, !dbg !0
+
+; Function Attrs: nounwind
+define signext i32 @foo(fp128 %p) #0 !dbg !12 {
+entry:
+  call void @llvm.dbg.value(metadata fp128 %p, metadata !17, metadata !DIExpression()), !dbg !18
+  store volatile fp128 %p, fp128* @global, align 16, !dbg !19
+  tail call void @clobber(), !dbg !20
+  ret i32 123, !dbg !21
+}
+
+declare void @clobber()
+
+; Function Attrs: nounwind readnone speculatable willreturn
+declare void @llvm.dbg.value(metadata, metadata, metadata) #1
+
+attributes #0 = { nounwind }
+attributes #1 = { nounwind readnone speculatable willreturn }
+
+!llvm.dbg.cu = !{!2}
+!llvm.module.flags = !{!8, !9, !10}
+!llvm.ident = !{!11}
+
+!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+!1 = distinct !DIGlobalVariable(name: "global", scope: !2, file: !3, line: 1, type: !6, isLocal: false, isDefinition: true)
+!2 = distinct !DICompileUnit(language: DW_LANG_C99, file: !3, producer: "clang version 10.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !5, nameTableKind: None)
+!3 = !DIFile(filename: "entry-value-complex-reg-expr.c", directory: "/")
+!4 = !{}
+!5 = !{!0}
+!6 = !DIDerivedType(tag: DW_TAG_volatile_type, baseType: !7)
+!7 = !DIBasicType(name: "long double", size: 128, encoding: DW_ATE_float)
+!8 = !{i32 2, !"Dwarf Version", i32 4}
+!9 = !{i32 2, !"Debug Info Version", i32 3}
+!10 = !{i32 1, !"wchar_size", i32 4}
+!11 = !{!"clang version 10.0.0"}
+!12 = distinct !DISubprogram(name: "foo", scope: !3, file: !3, line: 3, type: !13, scopeLine: 3, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !2, retainedNodes: !16)
+!13 = !DISubroutineType(types: !14)
+!14 = !{!15, !7}
+!15 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!16 = !{!17}
+!17 = !DILocalVariable(name: "p", arg: 1, scope: !12, file: !3, line: 3, type: !7, flags: DIFlagArgumentNotModified)
+!18 = !DILocation(line: 0, scope: !12)
+!19 = !DILocation(line: 4, scope: !12)
+!20 = !DILocation(line: 5, scope: !12)
+!21 = !DILocation(line: 6, scope: !12)

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

+; RUN: not opt -S < %s 2>&1 | FileCheck %s
+
+; We can only use the internal variant of the entry value operation,
+; DW_OP_LLVM_entry_value, in DIExpressions.
+
+!named = !{!0}
+; CHECK: invalid expression
+!0 = !DIExpression(DW_OP_entry_value, 1)

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)
+!0 = !DIExpression(DW_OP_LLVM_entry_value, 4, DW_OP_constu, 0, DW_OP_stack_value)
+!1 = !DIExpression(DW_OP_constu, 0, DW_OP_LLVM_entry_value, 1, DW_OP_constu, 0)
+!2 = !DIExpression(DW_OP_LLVM_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)
+!0 = !DIExpression(DW_OP_LLVM_entry_value, 1)