[LiveDebugValues] Emit parameter's entry value

[djtodoro]

Summary

Job of this pass to broadcast DBG_VALUES to the all successive blocks where its preserved location is valid. As a natural way it should emit replacements for clobbered parameters location.

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

[wolfgangp]

lib/CodeGen/LiveDebugValues.cpp

296 ↗

(On Diff #186226)

I would prefer either the name "ParameterEntryVals" or "ParamEntyrVals", throughout the file, instead of "ParametrEntryVals".

312 ↗

(On Diff #186226)

This type is used in several locations. Perhaps we could have a using declaration
for it and use a more compact name?

825 ↗

(On Diff #186226)

This is invariant in the for-loop, no? Perhaps it should be pulled ahead of it?

998 ↗

(On Diff #186226)

I think this comment needs perhaps some rephrasing. Something like:
Enter DEBUG_VALUE instructions that track parameters into ParameterEntryVals. When we encounter a variable that we have already entered, we assume that we have found all parameter
entry locations and stop.

1000 ↗

(On Diff #186226)

some spelling errors: wheter -> whether, vraible->variable, it->is

Suggested wording:
We check whether MI is inlined in order to deduce whether the variable that it tracks
comes from a different function. If that is the case we can't track its entry value.

[djtodoro]

@wolfgangp Thanks a lot for your comments! It has been addressed.

[djtodoro]

• Rename: VariableNotChanged ===> ArgumentNotModified
• Refactor a test case

[dstenb]

lib/CodeGen/LiveDebugValues.cpp

445–447 ↗

(On Diff #186613)

Should this use Expr->isEntryValue()? However, the implementation of that function in D58041 only checks if the first element is the operation:

bool isEntryValue() const {
    return getNumElements() > 0 && getElement(0) == dwarf::DW_OP_GNU_entry_value;
}

Is that correct, or should it look through all elements like is done here? Or is there some reason for why they should be disjunct? If so, could you add a comment here?

[NikolaPrica]

lib/CodeGen/LiveDebugValues.cpp

445–447 ↗

(On Diff #186613)

You are right! It should be isEntryValue()! Thanks!

[djtodoro]

• Use isEntryValue() from DIExpression

[dstenb]

lib/CodeGen/LiveDebugValues.cpp

445–447 ↗

(On Diff #186613)

Okay, thanks for the clarification. So DW_OP_GNU_entry_value will only be located in the first element then?

[djtodoro]

lib/CodeGen/LiveDebugValues.cpp

445–447 ↗

(On Diff #186613)

In the current design, yes.
DIExpression will always have entry value DWARF operand as first element.

[djtodoro]

-Rebase
-Follow-up with the new approach

[aprantl]

include/llvm/IR/DebugInfoMetadata.h

2529 ↗

(On Diff #195197)

The more flags we add these bool parameters get less and less safe, since the order isn't typesafe. We should probably think about also using an unsigned Flag parameter that is WithDeref | WithEntryValue.

2600 ↗

(On Diff #195197)

In LLVM IR I'd prefer using the DWARF 5 DW_OP_entry_value (Or a new LLVM one if we change the semantics). We can still emit the GNU variant, if requested.

According to the DWARF spec an entry value can appear anywhere in the dwarf expression, right? If we only accept one as the first element, we also need a verifier that enforces this.

lib/CodeGen/AsmPrinter/DwarfExpression.cpp

333 ↗

(On Diff #195197)

This should be DW_OP_entry_value if DWARF 5 is requested (or a perhaps GDB tuning)

lib/CodeGen/LiveDebugValues.cpp

450 ↗

(On Diff #195197)

Would it be possible to split this part into a separate patch?

[djtodoro]

include/llvm/IR/DebugInfoMetadata.h

2529 ↗

(On Diff #195197)

I agree with this.

2600 ↗

(On Diff #195197)

In LLVM IR I'd prefer using the DWARF 5 DW_OP_entry_value (Or a new LLVM one if we change the semantics). We can still emit the GNU variant, if requested.

We will make it.

According to the DWARF spec an entry value can appear anywhere in the dwarf expression, right?

Yes, but for now we support just basic entry values expressions.

If we only accept one as the first element, we also need a verifier that enforces this.

Sure.

lib/CodeGen/AsmPrinter/DwarfExpression.cpp

333 ↗

(On Diff #195197)

Sure.

lib/CodeGen/LiveDebugValues.cpp

450 ↗

(On Diff #195197)

IIUC, splitting introduction and production of entry_values makes sense.

[djtodoro]

-Use DW_OP_entry_value from DWARF 5
-Split up introduction and production of entry values

[djtodoro]

-Rebase

[aprantl]

lib/CodeGen/LiveDebugValues.cpp

211 ↗

(On Diff #196055)

Can you convert this into early-exit form?

if (Var != Other.Var)
  return Var < Other.Var;
...

432 ↗

(On Diff #196055)

The combination of TODO and also makes these sentences confusing to me.

454 ↗

(On Diff #196055)

factor out VarLocIDs[ID] (.Var.getVar()) for readability?

455 ↗

(On Diff #196055)

if (! ...)
  continue

468 ↗

(On Diff #196055)

auto &foo = **DMI;

482 ↗

(On Diff #196055)

Transfers.push_back({&MI, EntryValDbgMI});

[djtodoro]

lib/CodeGen/LiveDebugValues.cpp

211 ↗

(On Diff #196055)

Sure.

454 ↗

(On Diff #196055)

Sure.

[djtodoro]

-Addressing comments

[aprantl]

lib/CodeGen/LiveDebugValues.cpp

213 ↗

(On Diff #196431)

Now we're mixing both styles ;-)

if (Var != Other.Var)
  return Var < Other.Var;
if (Other.Kind != Kind)
  return Other.Kind < Kind;
return Loc.Hash < Other.Loc.Hash;

457 ↗

(On Diff #196431)

I'm having trouble making sense of DMI (debug machine instruction?) is there a better name?

956 ↗

(On Diff #196431)

Could this be a helper variable or function with a descriptive name that explains what this condition checks for?

[djtodoro]

lib/CodeGen/LiveDebugValues.cpp

213 ↗

(On Diff #196431)

Sorry. :)

457 ↗

(On Diff #196431)

We can try.

956 ↗

(On Diff #196431)

Sure.

[djtodoro]

-Refactor

[dstenb]

I cherry-picked the patches on top of r359425, and tried out some examples. Doing that, I encountered a case where entry values are not inserted with this patch.

When compiling the following code:

int global;
int foo(int p, int q, int r) {
  global = p + 1;
  asm __volatile ("" : : : "edi", "esi", "edx");
  return 123;
}

using the following clang invocation:

clang -O1 -g -Xclang -femit-param-entry-values -mllvm -stop-after=livedebugvalues

gives the following MIR:

body:             |
  bb.0.entry:
    liveins: $edi

    DBG_VALUE $edi, $noreg, !15, !DIExpression(), debug-location !18
    DBG_VALUE $edi, $noreg, !15, !DIExpression(), debug-location !18
    DBG_VALUE $esi, $noreg, !16, !DIExpression(), debug-location !19
    DBG_VALUE $edx, $noreg, !17, !DIExpression(), debug-location !20
    renamable $edi = nsw ADD32ri8 killed renamable $edi, 1, implicit-def dead $eflags, debug-location !21
    DBG_VALUE $edi, $noreg, !15, !DIExpression(DW_OP_entry_value, 1), debug-location !18
    MOV32mr $rip, 1, $noreg, @global, $noreg, killed renamable $edi, debug-location !22 :: (store 4 into @global, !tbaa !23)
    INLINEASM &"", 1, 12, implicit-def dead early-clobber $edi, 12, implicit-def dead early-clobber $esi, 12, implicit-def dead early-clobber $edx, 12, implicit-def dead early-clobber $df, 12, implicit-def dead early-clobber $fpsw, 12, implicit-def dead early-clobber $eflags, !28, debug-location !27
    $eax = MOV32ri 123, debug-location !29
    RETQ killed $eax, debug-location !29

As seen, there is an entry value location inserted for p after $edi is clobbered by the ADD32ri8 for p + q, but there are no entry value locations inserted for q and r after the inline assembly that clobbers their respective register. Is this perhaps due to some known limitation, or should this be considered a bug? Or have I overlooked something when testing this?

If I comment out the line that assigns the value to global, then LiveDebugValues emits entry value locations after the inline assembly for all three parameters.

[dstenb]

In D58042#1484188, @dstenb wrote:

I cherry-picked the patches on top of r359425, and tried out some examples. Doing that, I encountered a case where entry values are not inserted with this patch.

I had a look at this. LiveDebugValues::ExtendRanges() stops adding debug value instructions to ParamEntryVals as soon as it encounters a debug value for a variable that has already been seen, as pointed out by the "Insert DEBUG_VALUE instructions that track parameters into ParamEntryVals." block comment.

In this test case we are left with redundant DEBUG_VALUE instructions for p after LiveDebugVariables:

# *** IR Dump After Virtual Register Rewriter ***:                                                                                               
# Machine code for function foo: NoPHIs, TracksLiveness, NoVRegs, NoGlobalPredicates                                                             
Function Live Ins: $edi                                                                                                                          
                                                                                                                                                 
0B  bb.0.entry:                                                                                                                                  
      liveins: $edi                                                                                                                              
      DBG_VALUE $edi, $noreg, !"p", !DIExpression(), debug-location !18; kommentar.c:2:13 line no:2                                              
      DBG_VALUE $edi, $noreg, !"p", !DIExpression(), debug-location !18; kommentar.c:2:13 line no:2
      DBG_VALUE $esi, $noreg, !"q", !DIExpression(), debug-location !19; kommentar.c:2:20 line no:2                                              
      DBG_VALUE $edx, $noreg, !"r", !DIExpression(), debug-location !20; kommentar.c:2:27 line no:2

so that seems to be why entry values are not emitted for q and r, unless I have misunderstood something.

I don't know what it would take to stop LiveDebugVariables from emitting the redundant debug values in the first place. If it is not trivial, or there might perhaps be other cases where we can land in redundant entries, then perhaps this patch should be able to handle those entries?

[djtodoro]

@dstenb Thanks a lot for this test case! We should handle this as well.

[djtodoro]

-Handle more cases within LiveDebugValues::ExtendRanges()
-Add one more test
-Rebase

[aprantl]

lib/CodeGen/LiveDebugValues.cpp

215 ↗

(On Diff #199220)

FYI, I recently learned a neat trick:

return std::tie(Var, Kind, Hash) < std::tie(Other.Var, Other.Kind, Other.Hash);

IIUC, this is equivalent to the above code?

219 ↗

(On Diff #199220)

How was 6 derived (I'm asking because a non-power-of 2 always looks very deliberate).

298 ↗

(On Diff #199220)

If you don't want the vector size to leak into the function, you can use a SmallVectorImpl<MachineInstr *>

431 ↗

(On Diff #199220)

K -> Kind

598 ↗

(On Diff #199220)

IfAvailable ... can this return a nullptr?

935 ↗

(On Diff #199220)

I think the middle condition is redundant? Or do we expect SP to be 0?

952 ↗

(On Diff #199220)

return std::any_of()

[djtodoro]

lib/CodeGen/LiveDebugValues.cpp

215 ↗

(On Diff #199220)

This looks better. Thanks :)

219 ↗

(On Diff #199220)

It should be 8.

598 ↗

(On Diff #199220)

Yes, thanks.

[djtodoro]

-Address suggestions
-Rename ParamEntryVals into DebugEntryVals
-Avoid entry values on a frame reg and fragments (found those cases with better verifier)

[aprantl]

lib/CodeGen/LiveDebugValues.cpp

217 ↗

(On Diff #199794)

DebugParamSet is fine.

597 ↗

(On Diff #199794)

if (auto *TPC = getAnalysisIfAvailable<TargetPassConfig>())

[djtodoro]

-Address suggestions

[aprantl]

lib/CodeGen/LiveDebugValues.cpp

885 ↗

(On Diff #200035)

Can you land this as an NFC refactoring (no need for a separate phab review?)

966 ↗

(On Diff #200035)

We need a longer comment here that explains why each of these conditions are necessary and what is being checked for.

967 ↗

(On Diff #200035)

Why can't fragments be entry values?

[aprantl]

lib/CodeGen/LiveDebugValues.cpp

455 ↗

(On Diff #200035)

This is going into (low) n^2 territory here. Should we make DebugEntryVals a SmallPtrSet to avoid catastrophic behavior for functions with many arguments?

950 ↗

(On Diff #200035)

What does "New" mean here?

[djtodoro]

lib/CodeGen/LiveDebugValues.cpp

455 ↗

(On Diff #200035)

Mmm, we see.. But we will need another set for caching parameters debug variables, since we consider a parameters DBG_VALUE as a "new" if didn't encountered a debug variable from it.

885 ↗

(On Diff #200035)

Sure.

950 ↗

(On Diff #200035)

It means that a parameter is not collected yet inside the DebugEntryVals. We should name it IsParamEntryValueCollected or something like that.

966 ↗

(On Diff #200035)

Sure. We will add that.

967 ↗

(On Diff #200035)

Fragments can be entry values as well, but don't support it in this initial set of patches.
We will leave a TODO for that here.

[djtodoro]

-Use map instead of vector for storing debug entry values
-TODO: Land a separate patch with renaming DMI-->DebugInstr

[djtodoro]

-Addressing comments
-Avoid indirect dbg_values (in addition to SP and FP locations) in order to avoid memory locations as entry values locations

TODO: Rebase this on top of NFC D62295

[djtodoro]

-Refactor test cases a bit
-Rebase

[aprantl]

LGTM with an extra assertion

lib/CodeGen/LiveDebugValues.cpp

169 ↗

(On Diff #201513)

This looks dangerous.. are entry values somehow implicitly also register values? Iguess besed on the other patches the answer is yes, but that also means that we must assert((!EntryValueKind || RegNo) && "entry values must be register locations")

[djtodoro]

-Addressing suggestions

[djtodoro]

lib/CodeGen/LiveDebugValues.cpp

169 ↗

(On Diff #201513)

Yes, you are right! Thanks!

[djtodoro]

-Rebase tests

[dstenb]

Have you measured what the effect the emission of entry value locations has on the "scope bytes covered" statistics? I guess that it can increase quite a bit (especially later on if we start describing non-parameter variables using parameter entry values)? If so, if the caller(s) do not have call site information, it will still not be able to print the variable. Would it make sense, and would it be possible, to introduce a "scope bytes covered without entry values" statistic, or some other statistic, which helps you assess how large part of the locations that rely on entry values?

[djtodoro]

@dstenb Thanks for the comment!

Yes, we are constantly measuring debug location statistics. It is possible (and it makes sense) to extend the existing location statistic reporting, within LLVM, by avoiding locations that are entry values (we are actually working on that).

We will share the numbers.

[dstenb]

In D58042#1530823, @djtodoro wrote:

@dstenb Thanks for the comment!

Yes, we are constantly measuring debug location statistics. It is possible (and it makes sense) to extend the existing location statistic reporting, within LLVM, by avoiding locations that are entry values (we are actually working on that).

We will share the numbers.

Okay, thanks!

[djtodoro]

-Rebase

[djtodoro]

@aprantl This still looks OK after the rebasing? :)

[aprantl]

A rebase shouldn't affect the spirit of the change :-)

[djtodoro]

-Avoid a single location represented as an entry value (+ add a test for that)
-Allow a debug entry value after a first terminator

[djtodoro]

Nit: Use DWARF 5 in a test case.

[djtodoro]

Due to very latest patches we came up with situations when we need to avoid single location represented as an entry value.
Also, having in mind the debug entry value is special case of the 'DBG_VALUE' instruction, we found it is OK in some situations to generate it after a first terminator.
Is this still OK to go ?

[djtodoro]

-Clarify in the test the entry value coming from a location list

[aprantl]

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

1267 ↗

(On Diff #207294)

Can you change this comment from describing what the code does (which is fairly obvious), to why it does it?

thanks!

[dstenb]

lib/CodeGen/LiveDebugValues.cpp

1206 ↗

(On Diff #207294)

I'm sorry for the late comment, but in the future I guess this could be extended so that entry_values are emitted for locals that are expressed in terms of parameters, as GCC does?

For example:

int foo(int arg) {
  int local = arg + 3;
  clobber();
  return 0;
}

00000039 0000000000000004 000000000000000d (DW_OP_breg5 (rdi): 3; DW_OP_stack_value)
0000004e 000000000000000d 0000000000000018 (DW_OP_GNU_entry_value: (DW_OP_reg5 (rdi)); DW_OP_plus_uconst: 3; DW_OP_stack_value)
00000066 <End of list>

As far as I can tell, we don't tag non-parameter variables as NotModified, but can Clang later on be extended to mark them as such?

[djtodoro]

Can you change this comment from describing what the code does (which is fairly obvious), to why it does it?

@aprantl Sure. Thanks for the comment!

I'm sorry for the late comment, but in the future I guess this could be extended so that entry_values are emitted for locals that are expressed in terms of parameters, as GCC does?

@dstenb Thanks for your attention and comments. Sure, that is the plan. This is initial set of patches that covers just non-modified function parameters. Even the initial patch within the GCC was handling just this situation. The ways for improving this (using benefits of the debug entry values) are extending the support for modified parameters (if its modification could be described as an expression over its entry value), supporting local variables, etc.

As far as I can tell, we don't tag non-parameter variables as NotModified, but can Clang later on be extended to mark them as such?

Yes, it can be extended.

In addition, I did not forget about sharing the info about the debug location statistic measuring. :)
The 'llvm-dwarfdump' does calculate the debug location statistics, but maybe we could think of reporting it with more information, since the debug location info is such important debug info. Please find a proposal for having a separate tool that will calculate only the debug location statistics on my github (https://github.com/djolertrk/llvm-locstats) and let me know if it can be useful for us. Potentially, we could add more options, functionalities, etc..

[dstenb]

In D58042#1566136, @djtodoro wrote:

Can you change this comment from describing what the code does (which is fairly obvious), to why it does it?

@aprantl Sure. Thanks for the comment!

I'm sorry for the late comment, but in the future I guess this could be extended so that entry_values are emitted for locals that are expressed in terms of parameters, as GCC does?

@dstenb Thanks for your attention and comments. Sure, that is the plan. This is initial set of patches that covers just non-modified function parameters. Even the initial patch within the GCC was handling just this situation. The ways for improving this (using benefits of the debug entry values) are extending the support for modified parameters (if its modification could be described as an expression over its entry value), supporting local variables, etc.

As far as I can tell, we don't tag non-parameter variables as NotModified, but can Clang later on be extended to mark them as such?

Yes, it can be extended.

Okay, thanks for the clarification! Would it perhaps make sense to add a small sentence about that in those TODOs?

[djtodoro]

Would it perhaps make sense to add a small sentence about that in those TODOs?

@dstenb Sure! Thanks!

[djtodoro]

-Add support for entry values that are complex variables address (that avoids entry value not be safe for a single locations)
-Add a TODO for supporting local variables that are expressed in terms of parameters entry values

[djtodoro]

Is this OK to go ?

[dstenb]

In D58042#1566136, @djtodoro wrote:

The 'llvm-dwarfdump' does calculate the debug location statistics, but maybe we could think of reporting it with more information, since the debug location info is such important debug info. Please find a proposal for having a separate tool that will calculate only the debug location statistics on my github (https://github.com/djolertrk/llvm-locstats) and let me know if it can be useful for us. Potentially, we could add more options, functionalities, etc..

That seems like a useful tool!

Did you consider what should be done with llvm-dwarfdump's "scope bytes covered" statistics?

lib/CodeGen/LiveDebugValues.cpp

169 ↗

(On Diff #201513)

I think this should be Kind != EntryValueKind?

[djtodoro]

The 'llvm-dwarfdump' does calculate the debug location statistics, but maybe we could think of reporting it with more information, since the debug location info is such important debug info. Please find a proposal for having a separate tool that will calculate only the debug location statistics on my github (https://github.com/djolertrk/llvm-locstats) and let me know if it can be useful for us. Potentially, we could add more options, functionalities, etc..

That seems like a useful tool!

Thanks a lot for taking a look!

Did you consider what should be done with llvm-dwarfdump's "scope bytes covered" statistics?

I think that it sounds reasonable to add an additional field there, something like "non-entry-val scope bytes covered".

lib/CodeGen/LiveDebugValues.cpp

169 ↗

(On Diff #201513)

Oh, nice catch! Thanks!

[djtodoro]

-Fix the assertion

[dstenb]

In D58042#1570411, @djtodoro wrote:

Did you consider what should be done with llvm-dwarfdump's "scope bytes covered" statistics?

I think that it sounds reasonable to add an additional field there, something like "non-entry-val scope bytes covered".

Just to clarify, as the emission of entry values is behind a non-driver flag I'm not opposed to landing these patches without changing llvm-dwarfdump, so please don't let me stand in the way. I think that a "non-entry-val scope bytes covered" field would be helpful, but someone with more say in the debug info area than me should decide that.

[djtodoro]

Did you consider what should be done with llvm-dwarfdump's "scope bytes covered" statistics?

I think that it sounds reasonable to add an additional field there, something like "non-entry-val scope bytes covered".

Just to clarify, as the emission of entry values is behind a non-driver flag I'm not opposed to landing these patches without changing llvm-dwarfdump, so please don't let me stand in the way. I think that a "non-entry-val scope bytes covered" field would be helpful, but someone with more say in the debug info area than me should decide that.

@dstenb We could land this right now, and the patch for the 'llvm-dwarfdump' stats could be a separate patch. Do you agree?
Also, in the thread we could discuss about the new tool I shared.

[djtodoro]

-Nit in a comment

[dstenb]

In D58042#1571079, @djtodoro wrote:

@dstenb We could land this right now, and the patch for the 'llvm-dwarfdump' stats could be a separate patch. Do you agree?

Yes, that sounds good to me!

lib/CodeGen/LiveDebugValues.cpp

169 ↗

(On Diff #201513)

Also, I think we want to move the assertion out of this if statement? We want the check for all types of operands, not just for those that we have seen are register. (Currently, the RegNo check, with the assertion placed inside that if statement should mean that the assert can never fail.)

[djtodoro]

-Remove redundant code
-Fix the debug entry value assertion from the VarLoc constructor

[djtodoro]

Yes, that sounds good to me!

@dstenb Thanks!

lib/CodeGen/LiveDebugValues.cpp

169 ↗

(On Diff #201513)

Yes, it will never fail.
Also, the code looks much cleaner right now! Thanks!

llvm/trunk/lib/CodeGen/LiveDebugValues.cpp

 #include "llvm/CodeGen/MachineInstrBuilder.h"
 #include "llvm/CodeGen/MachineMemOperand.h"
 #include "llvm/CodeGen/MachineOperand.h"
 #include "llvm/CodeGen/PseudoSourceValue.h"
 #include "llvm/CodeGen/RegisterScavenging.h"
 #include "llvm/CodeGen/TargetFrameLowering.h"
 #include "llvm/CodeGen/TargetInstrInfo.h"
 #include "llvm/CodeGen/TargetLowering.h"
+#include "llvm/CodeGen/TargetPassConfig.h"
 #include "llvm/CodeGen/TargetRegisterInfo.h"
 #include "llvm/CodeGen/TargetSubtargetInfo.h"
 #include "llvm/Config/llvm-config.h"
 #include "llvm/IR/DIBuilder.h"
 #include "llvm/IR/DebugInfoMetadata.h"
 #include "llvm/IR/DebugLoc.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/Module.h"
struct VarLoc {
 
     const DebugVariable Var;
     const MachineInstr &MI; ///< Only used for cloning a new DBG_VALUE.
     mutable UserValueScopes UVS;
     enum VarLocKind {
       InvalidKind = 0,
       RegisterKind,
       SpillLocKind,
-      ImmediateKind
+      ImmediateKind,
+      EntryValueKind
     } Kind = InvalidKind;
 
     /// The value location. Stored separately to avoid repeatedly
     /// extracting it from MI.
     union {
       uint64_t RegNo;
       SpillLoc SpillLocation;
       uint64_t Hash;
       int64_t Immediate;
       const ConstantFP *FPImm;
       const ConstantInt *CImm;
     } Loc;
 
-    VarLoc(const MachineInstr &MI, LexicalScopes &LS)
-        : Var(MI), MI(MI), UVS(MI.getDebugLoc(), LS) {
+    VarLoc(const MachineInstr &MI, LexicalScopes &LS,
+          VarLocKind K = InvalidKind)
+        : Var(MI), MI(MI), UVS(MI.getDebugLoc(), LS), Kind(K) {
       static_assert((sizeof(Loc) == sizeof(uint64_t)),
                     "hash does not cover all members of Loc");
       assert(MI.isDebugValue() && "not a DBG_VALUE");
       assert(MI.getNumOperands() == 4 && "malformed DBG_VALUE");
       if (int RegNo = isDbgValueDescribedByReg(MI)) {
+        assert((!EntryValueKind || RegNo) &&
+               "entry values must be register locations");
+        if (Kind != EntryValueKind)
           Kind = RegisterKind;
         Loc.RegNo = RegNo;
       } else if (MI.getOperand(0).isImm()) {
         Kind = ImmediateKind;
         Loc.Immediate = MI.getOperand(0).getImm();
       } else if (MI.getOperand(0).isFPImm()) {
         Kind = ImmediateKind;
         Loc.FPImm = MI.getOperand(0).getFPImm();
       } else if (MI.getOperand(0).isCImm()) {
struct VarLoc {
     /// If this variable is described by a register, return it,
     /// otherwise return 0.
     unsigned isDescribedByReg() const {
       if (Kind == RegisterKind)
         return Loc.RegNo;
       return 0;
     }
 
+    bool isEntryValueKind() const {
+      return Kind == EntryValueKind;
+    }
+
     /// Determine whether the lexical scope of this value's debug location
     /// dominates MBB.
     bool dominates(MachineBasicBlock &MBB) const { return UVS.dominates(&MBB); }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
     LLVM_DUMP_METHOD void dump() const { MI.dump(); }
 #endif
 
     bool operator==(const VarLoc &Other) const {
       return Kind == Other.Kind && Var == Other.Var &&
              Loc.Hash == Other.Loc.Hash;
     }
 
     /// This operator guarantees that VarLocs are sorted by Variable first.
     bool operator<(const VarLoc &Other) const {
-      if (Var == Other.Var)
-        return Loc.Hash < Other.Loc.Hash;
-      return Var < Other.Var;
+      return std::tie(Var, Kind, Loc.Hash) <
+             std::tie(Other.Var, Other.Kind, Other.Loc.Hash);
     }
   };
 
+  using DebugParamMap = SmallDenseMap<const DILocalVariable *, MachineInstr *>;
   using VarLocMap = UniqueVector<VarLoc>;
   using VarLocSet = SparseBitVector<>;
   using VarLocInMBB = SmallDenseMap<const MachineBasicBlock *, VarLocSet>;
   struct TransferDebugPair {
     MachineInstr *TransferInst;
     MachineInstr *DebugInst;
   };
   using TransferMap = SmallVector<TransferDebugPair, 4>;
void insertTransferDebugPair(MachineInstr &MI, OpenRangesSet &OpenRanges,
                                TransferMap &Transfers, VarLocMap &VarLocIDs,
                                unsigned OldVarID, TransferKind Kind,
                                unsigned NewReg = 0);
 
   void transferDebugValue(const MachineInstr &MI, OpenRangesSet &OpenRanges,
                           VarLocMap &VarLocIDs);
   void transferSpillOrRestoreInst(MachineInstr &MI, OpenRangesSet &OpenRanges,
                                   VarLocMap &VarLocIDs, TransferMap &Transfers);
+  void emitEntryValues(MachineInstr &MI, OpenRangesSet &OpenRanges,
+                       VarLocMap &VarLocIDs, TransferMap &Transfers,
+                       DebugParamMap &DebugEntryVals,
+                       SparseBitVector<> &KillSet);
   void transferRegisterCopy(MachineInstr &MI, OpenRangesSet &OpenRanges,
                             VarLocMap &VarLocIDs, TransferMap &Transfers);
   void transferRegisterDef(MachineInstr &MI, OpenRangesSet &OpenRanges,
-                           const VarLocMap &VarLocIDs);
+                           VarLocMap &VarLocIDs, TransferMap &Transfers,
+                           DebugParamMap &DebugEntryVals);
   bool transferTerminatorInst(MachineInstr &MI, OpenRangesSet &OpenRanges,
                               VarLocInMBB &OutLocs, const VarLocMap &VarLocIDs);
 
   bool process(MachineInstr &MI, OpenRangesSet &OpenRanges,
                VarLocInMBB &OutLocs, VarLocMap &VarLocIDs,
-               TransferMap &Transfers, bool transferChanges,
-               OverlapMap &OverlapFragments, VarToFragments &SeenFragments);
+               TransferMap &Transfers, DebugParamMap &DebugEntryVals,
+               bool transferChanges, OverlapMap &OverlapFragments,
+               VarToFragments &SeenFragments);
 
   void accumulateFragmentMap(MachineInstr &MI, VarToFragments &SeenFragments,
                              OverlapMap &OLapMap);
 
   bool join(MachineBasicBlock &MBB, VarLocInMBB &OutLocs, VarLocInMBB &InLocs,
             const VarLocMap &VarLocIDs,
             SmallPtrSet<const MachineBasicBlock *, 16> &Visited,
             SmallPtrSetImpl<const MachineBasicBlock *> &ArtificialBlocks);
void LiveDebugValues::transferDebugValue(const MachineInstr &MI,
   assert(Var->isValidLocationForIntrinsic(DebugLoc) &&
          "Expected inlined-at fields to agree");
 
   // End all previous ranges of Var.
   DebugVariable V(Var, Expr, InlinedAt);
   OpenRanges.erase(V);
 
   // Add the VarLoc to OpenRanges from this DBG_VALUE.
+  VarLoc::VarLocKind Kind = VarLoc::InvalidKind;
   unsigned ID;
-  if (isDbgValueDescribedByReg(MI) || MI.getOperand(0).isImm() ||
-      MI.getOperand(0).isFPImm() || MI.getOperand(0).isCImm()) {
+
+  auto FinishVarLoc = [&] (const MachineInstr &MI, VarLoc::VarLocKind &Kind) {
     // Use normal VarLoc constructor for registers and immediates.
-    VarLoc VL(MI, LS);
+    VarLoc VL(MI, LS, Kind);
     ID = VarLocIDs.insert(VL);
     OpenRanges.insert(ID, VL.Var);
+  };
+
+  if (isDbgValueDescribedByReg(MI)) {
+    Kind = VarLoc::RegisterKind;
+    const DIExpression *Expr = MI.getDebugExpression();
+    if (Expr->isEntryValue())
+      Kind = VarLoc::EntryValueKind;
+    FinishVarLoc(MI, Kind);
+  } else if (MI.getOperand(0).isImm() ||
+             MI.getOperand(0).isFPImm() || MI.getOperand(0).isCImm()) {
+    Kind = VarLoc::ImmediateKind;
+    FinishVarLoc(MI, Kind);
   } else if (MI.hasOneMemOperand()) {
     // It's a stack spill -- fetch spill base and offset.
     VarLoc::SpillLoc SpillLocation = extractSpillBaseRegAndOffset(MI);
     VarLoc VL(MI, SpillLocation.SpillBase, SpillLocation.SpillOffset, LS);
     ID = VarLocIDs.insert(VL);
     OpenRanges.insert(ID, VL.Var);
   } else {
     // This must be an undefined location. We should leave OpenRanges closed.
     assert(MI.getOperand(0).isReg() && MI.getOperand(0).getReg() == 0 &&
            "Unexpected non-undef DBG_VALUE encountered");
   }
 }
 
+void LiveDebugValues::emitEntryValues(MachineInstr &MI,
+                                      OpenRangesSet &OpenRanges,
+                                      VarLocMap &VarLocIDs,
+                                      TransferMap &Transfers,
+                                      DebugParamMap &DebugEntryVals,
+                                      SparseBitVector<> &KillSet) {
+  MachineFunction *MF = MI.getParent()->getParent();
+  for (unsigned ID : KillSet) {
+    if (!VarLocIDs[ID].Var.getVar()->isParameter())
+      continue;
+
+    const MachineInstr *CurrDebugInstr = &VarLocIDs[ID].MI;
+
+    // If parameter's DBG_VALUE is not in the map that means we can't
+    // generate parameter's entry value.
+    if (!DebugEntryVals.count(CurrDebugInstr->getDebugVariable()))
+      continue;
+
+    auto ParamDebugInstr = DebugEntryVals[CurrDebugInstr->getDebugVariable()];
+    DIExpression *NewExpr = DIExpression::prepend(
+        ParamDebugInstr->getDebugExpression(), DIExpression::EntryValue);
+    MachineInstr *EntryValDbgMI =
+        BuildMI(*MF, ParamDebugInstr->getDebugLoc(), ParamDebugInstr->getDesc(),
+                ParamDebugInstr->isIndirectDebugValue(),
+                ParamDebugInstr->getOperand(0).getReg(),
+                ParamDebugInstr->getDebugVariable(), NewExpr);
+
+    if (ParamDebugInstr->isIndirectDebugValue())
+      EntryValDbgMI->getOperand(1).setImm(
+          ParamDebugInstr->getOperand(1).getImm());
+
+    Transfers.push_back({&MI, EntryValDbgMI});
+    VarLoc VL(*EntryValDbgMI, LS, VarLoc::EntryValueKind);
+    unsigned EntryValLocID = VarLocIDs.insert(VL);
+    OpenRanges.insert(EntryValLocID, VL.Var);
+  }
+}
+
 /// Create new TransferDebugPair and insert it in \p Transfers. The VarLoc
 /// with \p OldVarID should be deleted form \p OpenRanges and replaced with
 /// new VarLoc. If \p NewReg is different than default zero value then the
 /// new location will be register location created by the copy like instruction,
 /// otherwise it is variable's location on the stack.
 void LiveDebugValues::insertTransferDebugPair(
     MachineInstr &MI, OpenRangesSet &OpenRanges, TransferMap &Transfers,
     VarLocMap &VarLocIDs, unsigned OldVarID, TransferKind Kind,
LLVM_DEBUG(dbgs() << "Creating DBG_VALUE inst for register restore: ";
                                     /*AddNewLine*/true, TII));
     return;
   }
   }
   llvm_unreachable("Invalid transfer kind");
 }
 
 /// A definition of a register may mark the end of a range.
-void LiveDebugValues::transferRegisterDef(MachineInstr &MI,
-                                          OpenRangesSet &OpenRanges,
-                                          const VarLocMap &VarLocIDs) {
+void LiveDebugValues::transferRegisterDef(
+    MachineInstr &MI, OpenRangesSet &OpenRanges, VarLocMap &VarLocIDs,
+    TransferMap &Transfers, DebugParamMap &DebugEntryVals) {
   MachineFunction *MF = MI.getMF();
   const TargetLowering *TLI = MF->getSubtarget().getTargetLowering();
   unsigned SP = TLI->getStackPointerRegisterToSaveRestore();
   SparseBitVector<> KillSet;
   for (const MachineOperand &MO : MI.operands()) {
     // Determine whether the operand is a register def.  Assume that call
     // instructions never clobber SP, because some backends (e.g., AArch64)
     // never list SP in the regmask.
if (MO.isReg() && MO.isDef() && MO.getReg() &&
       for (unsigned ID : OpenRanges.getVarLocs()) {
         unsigned Reg = VarLocIDs[ID].isDescribedByReg();
         if (Reg && Reg != SP && MO.clobbersPhysReg(Reg))
           KillSet.set(ID);
       }
     }
   }
   OpenRanges.erase(KillSet, VarLocIDs);
+
+  if (auto *TPC = getAnalysisIfAvailable<TargetPassConfig>()) {
+    auto &TM = TPC->getTM<TargetMachine>();
+    if (TM.Options.EnableDebugEntryValues)
+      emitEntryValues(MI, OpenRanges, VarLocIDs, Transfers, DebugEntryVals,
+                      KillSet);
+  }
 }
 
 /// Decide if @MI is a spill instruction and return true if it is. We use 2
 /// criteria to make this decision:
 /// - Is this instruction a store to a spill slot?
 /// - Is there a register operand that is both used and killed?
 /// TODO: Store optimization can fold spills into other stores (including
 /// other spills). We do not handle this yet (more than one memory operand).
void LiveDebugValues::accumulateFragmentMap(MachineInstr &MI,
   }
 
   AllSeenFragments.insert(ThisFragment);
 }
 
 /// This routine creates OpenRanges and OutLocs.
 bool LiveDebugValues::process(MachineInstr &MI, OpenRangesSet &OpenRanges,
                               VarLocInMBB &OutLocs, VarLocMap &VarLocIDs,
-                              TransferMap &Transfers, bool transferChanges,
+                              TransferMap &Transfers, DebugParamMap &DebugEntryVals,
+                              bool transferChanges,
                               OverlapMap &OverlapFragments,
                               VarToFragments &SeenFragments) {
   bool Changed = false;
   transferDebugValue(MI, OpenRanges, VarLocIDs);
-  transferRegisterDef(MI, OpenRanges, VarLocIDs);
+  transferRegisterDef(MI, OpenRanges, VarLocIDs, Transfers,
+                      DebugEntryVals);
   if (transferChanges) {
     transferRegisterCopy(MI, OpenRanges, VarLocIDs, Transfers);
     transferSpillOrRestoreInst(MI, OpenRanges, VarLocIDs, Transfers);
   } else {
     // Build up a map of overlapping fragments on the first run through.
     if (MI.isDebugValue())
       accumulateFragmentMap(MI, SeenFragments, OverlapFragments);
   }
std::priority_queue<unsigned int, std::vector<unsigned int>,
                       std::greater<unsigned int>>
       Worklist;
   std::priority_queue<unsigned int, std::vector<unsigned int>,
                       std::greater<unsigned int>>
       Pending;
 
   enum : bool { dontTransferChanges = false, transferChanges = true };
 
+  // Besides parameter's modification, check whether a DBG_VALUE is inlined
+  // in order to deduce whether the variable that it tracks comes from
+  // a different function. If that is the case we can't track its entry value.
+  auto IsUnmodifiedFuncParam = [&](const MachineInstr &MI) {
+    auto *DIVar = MI.getDebugVariable();
+    return DIVar->isParameter() && DIVar->isNotModified() &&
+           !MI.getDebugLoc()->getInlinedAt();
+  };
+
+  const TargetLowering *TLI = MF.getSubtarget().getTargetLowering();
+  unsigned SP = TLI->getStackPointerRegisterToSaveRestore();
+  unsigned FP = TRI->getFrameRegister(MF);
+  auto IsRegOtherThanSPAndFP = [&](const MachineOperand &Op) -> bool {
+    return Op.isReg() && Op.getReg() != SP && Op.getReg() != FP;
+  };
+
+  // Working set of currently collected debug variables mapped to DBG_VALUEs
+  // representing candidates for production of debug entry values.
+  DebugParamMap DebugEntryVals;
+
+  MachineBasicBlock &First_MBB = *(MF.begin());
+  // Only in the case of entry MBB collect DBG_VALUEs representing
+  // function parameters in order to generate debug entry values for them.
+  // Currently, we generate debug entry values only for parameters that are
+  // unmodified throughout the function and located in a register.
+  // TODO: Add support for parameters that are described as fragments.
+  // TODO: Add support for modified arguments that can be expreseed
+  // by using its entry value.
+  for (auto &MI : First_MBB)
+    if (MI.isDebugValue() && IsUnmodifiedFuncParam(MI) &&
+        !MI.isIndirectDebugValue() && IsRegOtherThanSPAndFP(MI.getOperand(0)) &&
+        !DebugEntryVals.count(MI.getDebugVariable()) &&
+        !MI.getDebugExpression()->isFragment())
+      DebugEntryVals[MI.getDebugVariable()] = &MI;
+
   // Initialize every mbb with OutLocs.
   // We are not looking at any spill instructions during the initial pass
   // over the BBs. The LiveDebugVariables pass has already created DBG_VALUE
   // instructions for spills of registers that are known to be user variables
   // within the BB in which the spill occurs.
   for (auto &MBB : MF) {
     for (auto &MI : MBB) {
-      process(MI, OpenRanges, OutLocs, VarLocIDs, Transfers,
+      process(MI, OpenRanges, OutLocs, VarLocIDs, Transfers, DebugEntryVals,
               dontTransferChanges, OverlapFragments, SeenFragments);
     }
+    // Add any entry DBG_VALUE instructions necessitated by parameter
+    // clobbering.
+    for (auto &TR : Transfers) {
+      MBB.insertAfter(MachineBasicBlock::iterator(*TR.TransferInst),
+                     TR.DebugInst);
+    }
+    Transfers.clear();
   }
 
   auto hasNonArtificialLocation = [](const MachineInstr &MI) -> bool {
     if (const DebugLoc &DL = MI.getDebugLoc())
       return DL.getLine() != 0;
     return false;
   };
   for (auto &MBB : MF)
while (!Worklist.empty()) {
         MBBJoined = false;
         Changed = true;
         // Now that we have started to extend ranges across BBs we need to
         // examine spill instructions to see whether they spill registers that
         // correspond to user variables.
         for (auto &MI : *MBB)
           OLChanged |=
               process(MI, OpenRanges, OutLocs, VarLocIDs, Transfers,
-                      transferChanges, OverlapFragments, SeenFragments);
+                      DebugEntryVals, transferChanges, OverlapFragments,
+                      SeenFragments);
 
         // Add any DBG_VALUE instructions necessitated by spills.
         for (auto &TR : Transfers)
           MBB->insertAfter(MachineBasicBlock::iterator(*TR.TransferInst),
                            TR.DebugInst);
         Transfers.clear();
 
         LLVM_DEBUG(printVarLocInMBB(MF, OutLocs, VarLocIDs,

llvm/trunk/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 {{.*}}
+
+--- |
+  ; 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 {
+  entry:
+    call void @llvm.dbg.value(metadata i32 %x, metadata !14, metadata !DIExpression()), !dbg !18
+    call void @llvm.dbg.value(metadata i32 %y, metadata !15, metadata !DIExpression()), !dbg !18
+    call void @llvm.dbg.value(metadata i32 7, metadata !17, metadata !DIExpression()), !dbg !18
+    tail call void @fn2(i32 7), !dbg !18
+    ret void, !dbg !18
+  }
+  
+  declare !dbg !4 dso_local void @fn2(i32) local_unnamed_addr
+  
+  ; Function Attrs: nounwind readnone speculatable
+  declare void @llvm.dbg.value(metadata, metadata, metadata)
+  
+  
+  !llvm.dbg.cu = !{!0}
+  !llvm.module.flags = !{!5, !6, !7}
+  !llvm.ident = !{!8}
+  
+  !0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 9.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, retainedTypes: !3, nameTableKind: None)
+  !1 = !DIFile(filename: "test.c", directory: "/dir")
+  !2 = !{}
+  !3 = !{!4}
+  !4 = !DISubprogram(name: "fn2", scope: !1, file: !1, line: 11, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !2)
+  !5 = !{i32 2, !"Dwarf Version", i32 4}
+  !6 = !{i32 2, !"Debug Info Version", i32 3}
+  !7 = !{i32 1, !"wchar_size", i32 4}
+  !8 = !{!"clang version 9.0.0"}
+  !9 = distinct !DISubprogram(name: "fn1", scope: !1, file: !1, line: 15, type: !10, scopeLine: 15, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !13)
+  !10 = !DISubroutineType(types: !11)
+  !11 = !{null, !12, !12}
+  !12 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+  !13 = !{!14, !15, !16, !17}
+  !14 = !DILocalVariable(name: "x", arg: 1, scope: !9, file: !1, line: 15, type: !12, flags: DIFlagArgumentNotModified)
+  !15 = !DILocalVariable(name: "y", arg: 2, scope: !9, file: !1, line: 15, type: !12, flags: DIFlagArgumentNotModified)
+  !16 = !DILocalVariable(name: "u", scope: !9, file: !1, line: 16, type: !12, flags: DIFlagArgumentNotModified)
+  !17 = !DILocalVariable(name: "a", scope: !9, file: !1, line: 21, type: !12, flags: DIFlagArgumentNotModified)
+  !18 = !DILocation(line: 15, column: 10, scope: !9)
+
+...
+---
+name:            fn1
+alignment:       4
+tracksRegLiveness: true
+liveins:         []
+body:             |
+  bb.0.entry:
+    DBG_VALUE $edi, $noreg, !14, !DIExpression(), debug-location !18
+    DBG_VALUE $esi, $noreg, !15, !DIExpression(), debug-location !18
+    DBG_VALUE 7, $noreg, !17, !DIExpression(), debug-location !18
+    $edi = MOV32ri 7, debug-location !18
+    TAILJMPd64 @fn2, csr_64, implicit $rsp, implicit $ssp, implicit $rsp, implicit $ssp, implicit killed $edi, debug-location !18
+
+...

llvm/trunk/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
+# 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 {{.*}}
+
+--- |
+  ; 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
+  
+  define dso_local i32 @foo(i32 %p, i32 %q, i32 %r) local_unnamed_addr !dbg !11 {
+  entry:
+    call void @llvm.dbg.value(metadata i32 %p, metadata !15, metadata !DIExpression()), !dbg !18
+    call void @llvm.dbg.value(metadata i32 %q, metadata !16, metadata !DIExpression()), !dbg !18
+    call void @llvm.dbg.value(metadata i32 %r, metadata !17, metadata !DIExpression()), !dbg !18
+    %add = add nsw i32 %p, 1, !dbg !18
+    store i32 %add, i32* @global, align 4, !dbg !18
+    tail call void asm sideeffect "", "~{edi},~{esi},~{edx},~{dirflag},~{fpsr},~{flags}"(), !dbg !18, !srcloc !19
+    ret i32 123, !dbg !18
+  }
+  
+  ; Function Attrs: nounwind readnone speculatable
+  declare void @llvm.dbg.value(metadata, metadata, metadata)
+  
+  !llvm.dbg.cu = !{!2}
+  !llvm.module.flags = !{!7, !8, !9}
+  !llvm.ident = !{!10}
+  
+  !0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+  !1 = distinct !DIGlobalVariable(name: "global", scope: !2, file: !3, line: 8, type: !6, isLocal: false, isDefinition: true)
+  !2 = distinct !DICompileUnit(language: DW_LANG_C99, file: !3, producer: "clang version 9.0.0 ", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !5, nameTableKind: None)
+  !3 = !DIFile(filename: "multiple-param-dbg-value-entry.c", directory: "/")
+  !4 = !{}
+  !5 = !{!0}
+  !6 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+  !7 = !{i32 2, !"Dwarf Version", i32 4}
+  !8 = !{i32 2, !"Debug Info Version", i32 3}
+  !9 = !{i32 1, !"wchar_size", i32 4}
+  !10 = !{!"clang version 9.0.0 "}
+  !11 = distinct !DISubprogram(name: "foo", scope: !3, file: !3, line: 9, type: !12, scopeLine: 9, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !2, retainedNodes: !14)
+  !12 = !DISubroutineType(types: !13)
+  !13 = !{!6, !6, !6, !6}
+  !14 = !{!15, !16, !17}
+  !15 = !DILocalVariable(name: "p", arg: 1, scope: !11, file: !3, line: 9, type: !6, flags: DIFlagArgumentNotModified)
+  !16 = !DILocalVariable(name: "q", arg: 2, scope: !11, file: !3, line: 9, type: !6, flags: DIFlagArgumentNotModified)
+  !17 = !DILocalVariable(name: "r", arg: 3, scope: !11, file: !3, line: 9, type: !6, flags: DIFlagArgumentNotModified)
+  !18 = !DILocation(line: 9, column: 13, scope: !11)
+  !19 = !{i32 213}
+
+...
+---
+name:            foo
+alignment:       4
+tracksRegLiveness: true
+liveins:         
+  - { reg: '$edi' }
+body:             |
+  bb.0.entry:
+    liveins: $edi
+  
+    DBG_VALUE $edi, $noreg, !15, !DIExpression(), debug-location !18
+    DBG_VALUE $edi, $noreg, !15, !DIExpression(), debug-location !18
+    DBG_VALUE $esi, $noreg, !16, !DIExpression(), debug-location !18
+    DBG_VALUE $edx, $noreg, !17, !DIExpression(), debug-location !18
+    renamable $edi = nsw INC32r killed renamable $edi, implicit-def dead $eflags, debug-location !18
+    MOV32mr $rip, 1, $noreg, @global, $noreg, killed renamable $edi, debug-location !18 :: (store 4 into @global)
+    INLINEASM &"", 1, 12, implicit-def dead early-clobber $edi, 12, implicit-def dead early-clobber $esi, 12, implicit-def dead early-clobber $edx, 12, implicit-def dead early-clobber $df, 12, implicit-def dead early-clobber $fpsw, 12, implicit-def dead early-clobber $eflags, !19, debug-location !18
+    $eax = MOV32ri 123, debug-location !18
+    RETQ killed $eax, debug-location !18
+
+...