[DebugInfo] Enable the debug entry values feature by default

[djtodoro]

Summary

This patch enables the debug entry values feature.
We have built the LLVM project, and a few more complex apps, with the patch applied.

Done:

• Remove the experimental -femit-debug-entry-values option
• Enable it for x86, arm and aarch64
• Resolve the test failures
• Leave the llc experimental option for targets that do not support the CallSiteInfo yet

TODO:

• Add some notes into the ReleaseNotes

[djtodoro]

The Umbrella for the issues related to the call_site/entry_vals features: https://bugs.llvm.org/show_bug.cgi?id=44116.

[dstenb]

llvm/lib/CodeGen/MachineLICM.cpp

1370–1371 ↗

(On Diff #240798)

Would it be possible to move these eraseCallSiteInfo() / moveCallSiteInfo() fixes to parent patch(es)? I guess that would mean that -debug-entry-values would have to be added to a number of tests where you saw those issues, just to be removed by this patch again, but I think it may overall make it easier to review the changes.

[djtodoro]

llvm/lib/CodeGen/MachineLICM.cpp

1370–1371 ↗

(On Diff #240798)

That makes sense to me.

I did not want to do such thing because we will need to remove the experimental flag, but I see that is the only option to see the reason for the *CallSiteInfo() changes.

[dstenb]

llvm/test/DebugInfo/MIR/Hexagon/dbgcall-site-instr-before-bundled-call.mir

1–3

Is there any clean way we could force call site information, e.g. via a llc flag, for these now-unsupported tests? I guess there might be quite a bit of work of getting call site information up and running on these targets, which AFAIK no one is looking into at the moment, so I wonder if these tests risk laying unsupported here for a while?

(Since I added these Hexagon/Sparc/SystemZ tests, I just want to mention that I wrote them as upstream reproducers for issues I saw with our downstream DSP target. I currently do not have any plans on working on enabling call site information for any of those upstream targets.)

[dblaikie]

Do you have size measurements for the impact of this change (on, say, a self-host optimized build of clang)?

& I think it's probably best to just change the default value of the flag - rather than changing the default and removing the flag. Giving folks some time with an escape hatch might be important.

Is this patch intended for commit - or as a preview/working area? It seems it's got a bunch of things that could/should be done in independent commits (like the "Fix the assertions regarding updating the CallSiteInfo from the MF" parts, for instance - perhaps that was what was raised by another reviewer earlier).

llvm/include/llvm/Target/TargetMachine.h

240–242

Why is this a target machine feature? What aspect of debug entry values is target specific? Is there something about their architectures that makes it unrepresentable? (that seems drastic given the generality of the feature)

I'm just a bit hesitant to introduce target divergence if it can reasonably be avoided - it'll make debug info comparisons, cross platform work, etc, more difficult.

[djtodoro]

In D73534#1845277, @dblaikie wrote:

Do you have size measurements for the impact of this change (on, say, a self-host optimized build of clang)?

I will share these.

& I think it's probably best to just change the default value of the flag - rather than changing the default and removing the flag. Giving folks some time with an escape hatch might be important.

I agree, thanks for the point!

Is this patch intended for commit - or as a preview/working area? It seems it's got a bunch of things that could/should be done in independent commits (like the "Fix the assertions regarding updating the CallSiteInfo from the MF" parts, for instance - perhaps that was what was raised by another reviewer earlier).

That's why I've marked it as a 'WIP'. I am working on splitting the changes into reasonable parts.

llvm/include/llvm/Target/TargetMachine.h

240–242

Since the debug entry values feature relies on the CallSiteInfo (that holds info about arguments and their transferring registers) which is target dependent, the whole feature is target dependent. The CallSiteInfo is being created during the ISel phase, when it performs the call lowering, which is also target dependent. Perhaps renaming the SupportsDebugEntryValues into something like SupportsCallSiteInfo would make sense here?

The idea of introducing the CallSiteInfo was that it could be used by some other tools or parts of the LLVM project. There was a discussion about that on the llvm-dev.

I'm just a bit hesitant to introduce target divergence if it can reasonably be avoided - it'll make debug info comparisons, cross platform work, etc, more difficult.

Maybe an option for disabling the feature will be useful too for that purpose?

llvm/test/DebugInfo/MIR/Hexagon/dbgcall-site-instr-before-bundled-call.mir

1–3

Is there any clean way we could force call site information, e.g. via a llc flag, for these now-unsupported tests?

I see.. I do not now for any other way. Maybe we should keep the option, and change the default value only.

I guess there might be quite a bit of work of getting call site information up and running on these targets, which AFAIK no one is looking into at the moment, so I wonder if these tests risk laying unsupported here for a while?

I think so. But we should keep the implementation up-to-date even for the targets that missing support for the CallSiteInfo production.

[vsk]

I ran CTMark using a stage1 Release clang as my compiler, with and without -Xclang -femit-debug-entry-values set using the 'Os-g.cmake' cache file. The compile time difference on my Mac was in the noise (however the machine was not stabilized for perf measurements):

Config	CTMark Geomean (seconds)	Mean	Stddev	Range	# Projects
-Os -g -j1	14.0828	16.0467	8.63911	[6.8003, 35.4556]	10
-Os -g -Xclang -femit-debug-entry-values -j1	14.0741	15.9379	8.3288	[6.8240, 34.5410]	10

In the entryvals CTMark run, the total size of DWARF sections in the .o's grew from 52166507 bytes (baseline) to 53249808 bytes [1], a 2% size increase. I'll try to grab numbers for a stage2 build tomorrow.

ctmark-Os-g-j1.json8 KBDownload

ctmark-Os-g-entryvals-j1.json8 KBDownload

[1] find . -name \*.o -exec size -m {} \; | grep "Section (__DWARF" | sumcol 4

[djtodoro]

• Make the 'fix the asserts' as a separate patch (D73700)
• Leave the llc experimental option for targets that do not support the CallSiteInfo yet

[djtodoro]

@vsk Thanks a lot for sharing this!

(however the machine was not stabilized for perf measurements)

What can be the reason of that?

I have also measure the impact on the size, build time and debug location coverage, on the LLVM built binaries with/out the feature. I see that there is no build time difference, the size of the binaries was increased a bit, but it is also minor.

1. llc binary
   • with no entry values: .debug_loc 241Mi (21.3% of the whole binary)
   • with entry values: .debug_loc 245Mi (21.5% of the whole binary)
2. lldb binary
   • with no entry values: .debug_loc 4.17Mi (34.1% of the whole binary)
   • with entry values: .debug_loc 4.23Mi (34.3% of the whole binary)

(Please find additional numbers within the file shared.)

The debug location coverage increased (got with the llvm-locstats --only-formal-parameters --compare on the lldb binaries built with/out the entry values):

Please find the additional numbers regarding the debug location improvements within the measurements-debug-entry-vals.txt.

measurements-debug-entry-vals.txt9 KBDownload

[vsk]

In D73534#1849382, @djtodoro wrote:

@vsk Thanks a lot for sharing this!

(however the machine was not stabilized for perf measurements)

What can be the reason of that?

Stabilization entails removing variables from the system that can affect performance. This usually entails killing extraneous background processes and disabling cpu frequency scaling. This can make the system hard to use (e.g. our stabilization script kills the bluetooth daemon, which I need to type).

I have some numbers for stage2 clang builds on macOS:

Config	dSYM Size (bytes)	Aggregate DWARF size in .o's (bytes) [1]	# of call site DIEs	# of call site parameters
Stage2 RelWithDebInfo	1682677554	8058178927	417517	0
Stage2 RelWithDebInfo + entryvals	1691586966	8069013985	417517	584620

EDIT: I miscounted earlier. I looked at the number of 'call site entries' instead of the number of 'call site DIEs'. I've updated the table with the correct numbers, which look fine to me.

[1] Just summing the size of all 'DWARF' sections in all .o's in the build directory, as before.

[djtodoro]

In D73534#1850372, @vsk wrote:

In D73534#1849382, @djtodoro wrote:

@vsk Thanks a lot for sharing this!

(however the machine was not stabilized for perf measurements)

What can be the reason of that?

Stabilization entails removing variables from the system that can affect performance. This usually entails killing extraneous background processes and disabling cpu frequency scaling. This can make the system hard to use (e.g. our stabilization script kills the bluetooth daemon, which I need to type).

OK, thanks for the info. I see, you said your machine was not stable. I thought the debug_infomade the performance to looking bad. Sorry :)

I have some numbers for stage2 clang builds on macOS:

Config	dSYM Size (bytes)	Aggregate DWARF size in .o's (bytes) [1]	# of call site DIEs	# of call site parameters
Stage2 RelWithDebInfo	1682677554	8058178927	417517	0
Stage2 RelWithDebInfo + entryvals	1691586966	8069013985	417517	584620

EDIT: I miscounted earlier. I looked at the number of 'call site entries' instead of the number of 'call site DIEs'. I've updated the table with the correct numbers, which look fine to me.

[1] Just summing the size of all 'DWARF' sections in all .o's in the build directory, as before.

Thanks for sharing this! The numbers look very good to me!

[djtodoro]

-Rebase

[vsk]

llvm/include/llvm/Target/TargetMachine.h

240–242

I think this flag logically makes sense as part of TargetMachine, but the name seems strange. I think all targets support "call site info" in the sense of DW_TAG_call_site. I think this should be renamed to SupportsDebugEntryValues.

llvm/lib/CodeGen/MachineFunction.cpp

871

Could you just add a shouldEmitDebugEntryValues predicate to TargetOptions that checks both flags, and use that everywhere? Also, please use || for logical ops.

[djtodoro]

llvm/include/llvm/Target/TargetMachine.h

240–242

It makes sense to me.

[djtodoro]

-Rename the flag
-Make the target-option predicate

[vsk]

LGTM with an updated comment. I'll start a thread on llvm-dev about getting this patch landed soon, as everyone interested in this work may not have been following the patches. Perhaps it'd be best to wait to land this until folks have had 1-2 work days to respond to the thread.

llvm/include/llvm/Target/TargetOptions.h

262

Better description might be: When set to true, the EnableDebugEntryValues option forces production of debug entry values even if the target does not officially support it. Useful for testing purposes only. This flag should never be checked directly, always use \ref ShouldEmitDebugEntryValues instead.

[vsk]

Hm, does this turn on entry values at -O0? Could you please add a clang test that ensures that at -O0 + -gdwarf5 + lldb/gdb tuning, entry values are not emitted?

[probinson]

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

853–854

This implementation makes it impractical to enable entry-values while still using SCE tuning. The Sony debugger people will want to be able to do that.

And in fact this is not how tuning controls are supposed to work. There should be a flag in DwarfDebug, initialized in the ctor, which has a *default* based on the tuning; but the flag can still be overridden regardless of tuning, by a command-line option just as many other tuning-related options are handled in the DwarfDebug ctor.

Based on comments by @vsk on the llvm-dev thread, I think you are trying to track all of the following conditions: (1) the target supports *tracking* entry values; (2) someone wants to *track* entry values even if the target doesn't support it by default; (3) whether to *emit* entry values in the DWARF. Currently (3) is not user-selectable because it is hard-coded based on tuning; this is a bug.

I would also rather not have two separate command-line options for (2) and (3), but if that's what we need, so be it.

[djtodoro]

-Add a test case for -O0 ensuring we do not emit the entry values
-Add an option within DwarfDebug that enables emitting the entry values
-Add a test case for the SCE tuning + emit-debug-entry-values

[djtodoro]

In D73534#1864855, @vsk wrote:

Hm, does this turn on entry values at -O0? Could you please add a clang test that ensures that at -O0 + -gdwarf5 + lldb/gdb tuning, entry values are not emitted?

We do not generate the debug entry values for the -O0. The test is added.

llvm/include/llvm/Target/TargetOptions.h

262

Very good, thanks! :)

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

853–854

@probinson Thanks for the comment! I agree.

I would also rather not have two separate command-line options for (2) and (3), but if that's what we need, so be it.

I think (2) and (3) are different, so I've introduced the -emit-debug-entry-values within DwarfDebug.

[vsk]

lgtm with a nit, but please wait for @probinson to confirm that the debugger tuning issue is sorted out.

llvm/test/DebugInfo/X86/loclists-dwp.ll

23

nice :)

llvm/test/DebugInfo/X86/no-entry-values-with-O0.ll

7

Please add a note here explaining that entry values /would/ get emitted if the 'AllCallsDescribed' DIFlag was set on fn1's subprogram.

[probinson]

Functionally looks fine, see where I think the commentary should be adjusted.

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

427

Emit call-site-param debug info for GDB and LLDB, if the target supports it. Can also be enabled explicitly.

855

Optionally emit call-site-param debug info.
(This is no longer the place where the gdb/lldb decision is made.)

[djtodoro]

-Addressing comments

[djtodoro]

How does it look now? :)

[vsk]

Looks great. Thanks!

[djtodoro]

Reverted due to http://lab.llvm.org:8011/builders/clang-with-thin-lto-ubuntu/builds/21373/steps/build-stage3-compiler/logs/stdio.

I will reland this as soon as I fix the issue.

[dstenb]

llvm/lib/CodeGen/SelectionDAG/ScheduleDAGSDNodes.cpp

870

I'm sorry for commenting on this so late, but when now adapting this patch for our downstream target, for which we will not enable call site info by default yet, I noticed that the call site information wasn't added. I think that this should be ShouldEmitDebugEntryValues().

[djtodoro]

llvm/lib/CodeGen/SelectionDAG/ScheduleDAGSDNodes.cpp

870

I thought to restrict the production of the call site info here and only to allow a hand-made testing, but I think you are right, we should use the ShouldEmitDebugEntryValues(). I'll update the patch, thanks!

[dstenb]

llvm/lib/CodeGen/SelectionDAG/ScheduleDAGSDNodes.cpp

870

Thanks! It is perhaps a bit of a corner case, and we're moving towards enabling call site info by default, but I guess this might be useful when experimenting with adding call site info for other targets in the future.

[djtodoro]

-Addressing the latest comments

[stella.stamenova]

It looks like this broke the windows lldb bot:

lab.llvm.org:8011/builders/lldb-x64-windows-ninja/builds/13902

[djtodoro]

Thanks for reporting that, are you sure this was the cause of the failure? I'll revert this while investigate, but it does not seem to me this is related to this patch.

[stella.stamenova]

I am not sure this was the cause of the failure, but other than your patches, there was only one other change in the first failing build. I have not had time to fully investigate yet.

[stella.stamenova]

In D73534#1880790, @stella.stamenova wrote:

I am not sure this was the cause of the failure, but other than your patches, there was only one other change in the first failing build. I have not had time to fully investigate yet.

It looks like the issue was fixed and it was not this change: http://lab.llvm.org:8011/builders/lldb-x64-windows-ninja/builds/13911

Thanks for looking into it!

[djtodoro]

I’ve already reverted the patch, but I’ll reland it again tomorrow. Thanks.

[nickdesaulniers]

As a heads up, Linaro's ToolChain Working Group's Linux kernel CI lit up on this change. I see it's been reverted (thank you). Please cc me on the updated patch and I can help test it against the Linux kernel.

Edit: Link: https://ci.linaro.org/job/tcwg_kernel-bisect-llvm-master-arm-mainline-allyesconfig/25/artifact/artifacts/build-a82d3e8a6e67473c94a5ce6345372748e9b61718/03-build_linux/console.log

[dstenb]

In D73534#1881353, @nickdesaulniers wrote:

As a heads up, Linaro's ToolChain Working Group's Linux kernel CI lit up on this change. I see it's been reverted (thank you). Please cc me on the updated patch and I can help test it against the Linux kernel.

Edit: Link: https://ci.linaro.org/job/tcwg_kernel-bisect-llvm-master-arm-mainline-allyesconfig/25/artifact/artifacts/build-a82d3e8a6e67473c94a5ce6345372748e9b61718/03-build_linux/console.log

Its hard to tell from the backtrace, but looking at the code, I think this might be a bug that sneaked in when I did D70431. Sorry if that is the case!

ARMBaseInstrInfo::isAddImmediate() does a getReg() without any isReg() guard:

Optional<RegImmPair> ARMBaseInstrInfo::isAddImmediate(const MachineInstr &MI,                                                                                                                                                                                                                                                  
                                                      Register Reg) const {                                                                                                                                                                                                                                                    
[...]
  // TODO: Handle cases where Reg is a super- or sub-register of the                                                                                                                                                                                                                                                           
  // destination register.
  if (Reg != MI.getOperand(0).getReg())
    return None;

[djtodoro]

In D73534#1882118, @dstenb wrote:

In D73534#1881353, @nickdesaulniers wrote:

As a heads up, Linaro's ToolChain Working Group's Linux kernel CI lit up on this change. I see it's been reverted (thank you). Please cc me on the updated patch and I can help test it against the Linux kernel.

Edit: Link: https://ci.linaro.org/job/tcwg_kernel-bisect-llvm-master-arm-mainline-allyesconfig/25/artifact/artifacts/build-a82d3e8a6e67473c94a5ce6345372748e9b61718/03-build_linux/console.log

Its hard to tell from the backtrace, but looking at the code, I think this might be a bug that sneaked in when I did D70431. Sorry if that is the case!

ARMBaseInstrInfo::isAddImmediate() does a getReg() without any isReg() guard:

Optional<RegImmPair> ARMBaseInstrInfo::isAddImmediate(const MachineInstr &MI,                                                                                                                                                                                                                                                  
                                                      Register Reg) const {                                                                                                                                                                                                                                                    
[...]
  // TODO: Handle cases where Reg is a super- or sub-register of the                                                                                                                                                                                                                                                           
  // destination register.
  if (Reg != MI.getOperand(0).getReg())
    return None;

@dstenb No problem, we have already addressed the issue. Thanks to @vsk and @nickdesaulniers! I'll update the patch.

[djtodoro]

• Address the issue with ARM describeLoadedValue() (thanks to @vsk, I've reduced the test llvm/test/DebugInfo/MIR/ARM/dbgcallsite-noreg-is-imm-check.mir)

[dstenb]

In D73534#1882127, @djtodoro wrote:

@dstenb No problem, we have already addressed the issue. Thanks to @vsk and @nickdesaulniers! I'll update the patch.

Great, thanks!

[nickdesaulniers]

In D73534#1882136, @djtodoro wrote:

• Address the issue with ARM describeLoadedValue() (thanks to @vsk, I've reduced the test llvm/test/DebugInfo/MIR/ARM/dbgcallsite-noreg-is-imm-check.mir)

I'd like to help test this, but arc patch D73534 is now failing with merge conflicts. Can you please rebase this on master?

[djtodoro]

In D73534#1883022, @nickdesaulniers wrote:

In D73534#1882136, @djtodoro wrote:

• Address the issue with ARM describeLoadedValue() (thanks to @vsk, I've reduced the test llvm/test/DebugInfo/MIR/ARM/dbgcallsite-noreg-is-imm-check.mir)

I'd like to help test this, but arc patch D73534 is now failing with merge conflicts. Can you please rebase this on master?

I’ve already pushed this. Please rebase on the latest commits.

[nickdesaulniers]

In D73534#1883048, @djtodoro wrote:

I’ve already pushed this. Please rebase on the latest commits.

Ah faff707db82d7db12fcd9f7826b8741261230e63. Cool, I can no longer reproduce the previous issue. Thanks for the quick fix.

[ostannard]

There's a failure on an ARM 2-stage buildbot which looks related to this: http://lab.llvm.org:8011/builders/clang-cmake-thumbv7-full-sh/builds/3920/steps/build%20stage%202/logs/stdio

I can reproduce the crash on the buildbot machine, so hopefully I'll have a standalone reproducer for you soon.

[djtodoro]

@ostannard Thanks for reporting that! Please share the case.

[djtodoro]

Reverted again with rG2f215cf36adc. The investigation is needed.

[ostannard]

Reproducer for that crash: P8198 P8199

[djtodoro]

Nice! Thanks!

[mstorsjo]

This broke compiling for mingw, repro.c:

a(short);
b() { a(1); }

clang -target x86_64-w64-mingw32 -c repro.c -g -O2, which gives Assertion '!MI.isMoveImmediate() && "Unexpected MoveImm instruction"' failed.

[djtodoro]

In D73534#1915048, @mstorsjo wrote:

This broke compiling for mingw, repro.c:

a(short);
b() { a(1); }

clang -target x86_64-w64-mingw32 -c repro.c -g -O2, which gives Assertion '!MI.isMoveImmediate() && "Unexpected MoveImm instruction"' failed.

Thanks for reporting this! Since this is the case of the X86::MOV16ri the D75326 will solve this issue.

[djtodoro]

In D73534#1916291, @djtodoro wrote:

In D73534#1915048, @mstorsjo wrote:

This broke compiling for mingw, repro.c:

a(short);
b() { a(1); }

clang -target x86_64-w64-mingw32 -c repro.c -g -O2, which gives Assertion '!MI.isMoveImmediate() && "Unexpected MoveImm instruction"' failed.

Thanks for reporting this! Since this is the case of the X86::MOV16ri the D75326 will solve this issue.

The alternative is D75974.

[djtodoro]

In D73534#1916309, @djtodoro wrote:

In D73534#1916291, @djtodoro wrote:

In D73534#1915048, @mstorsjo wrote:

This broke compiling for mingw, repro.c:

a(short);
b() { a(1); }

clang -target x86_64-w64-mingw32 -c repro.c -g -O2, which gives Assertion '!MI.isMoveImmediate() && "Unexpected MoveImm instruction"' failed.

Thanks for reporting this! Since this is the case of the X86::MOV16ri the D75326 will solve this issue.

The alternative is D75974.

The D75974 is commited.

[mstorsjo]

In D73534#1918818, @djtodoro wrote:

In D73534#1916309, @djtodoro wrote:

In D73534#1916291, @djtodoro wrote:

Thanks for reporting this! Since this is the case of the X86::MOV16ri the D75326 will solve this issue.

The alternative is D75974.

The D75974 is commited.

Thanks!

[manojgupta]

Hi,

I see another crash with this change when building gdb.

Reduced test case:
struct type *a(type *, type *, long, long);
enum b {};
static int empty_array(type *, int c) { type *d = a(__null, d, c, c - 1); }
long e;
b f() { empty_array(0, e); }

Repros with:
clang -cc1 -triple x86_64-linux-gnu -emit-obj -disable-free -mrelocation-model pic -pic-level 2 -pic-is-pie -mthread-model posix -mframe-pointer=all -mconstructor-aliases -munwind-tables -dwarf-column-info -debug-info-kind=limited -dwarf-version=4 -debugger-tuning=gdb -O2 -x c++

Chromium bug: https://bugs.chromium.org/p/chromium/issues/detail?id=1060788

[dstenb]

In D73534#1918890, @manojgupta wrote:

Hi,

I see another crash with this change when building gdb.

Reduced test case:
struct type *a(type *, type *, long, long);
enum b {};
static int empty_array(type *, int c) { type *d = a(__null, d, c, c - 1); }
long e;
b f() { empty_array(0, e); }

Repros with:
clang -cc1 -triple x86_64-linux-gnu -emit-obj -disable-free -mrelocation-model pic -pic-level 2 -pic-is-pie -mthread-model posix -mframe-pointer=all -mconstructor-aliases -munwind-tables -dwarf-column-info -debug-info-kind=limited -dwarf-version=4 -debugger-tuning=gdb -O2 -x c++

Chromium bug: https://bugs.chromium.org/p/chromium/issues/detail?id=1060788

Oh, that assertion is related to D75036 which I did. I can have a look at that.

[dstenb]

In D73534#1918940, @dstenb wrote:

In D73534#1918890, @manojgupta wrote:

Hi,

I see another crash with this change when building gdb.

Reduced test case:
struct type *a(type *, type *, long, long);
enum b {};
static int empty_array(type *, int c) { type *d = a(__null, d, c, c - 1); }
long e;
b f() { empty_array(0, e); }

Repros with:
clang -cc1 -triple x86_64-linux-gnu -emit-obj -disable-free -mrelocation-model pic -pic-level 2 -pic-is-pie -mthread-model posix -mframe-pointer=all -mconstructor-aliases -munwind-tables -dwarf-column-info -debug-info-kind=limited -dwarf-version=4 -debugger-tuning=gdb -O2 -x c++

Chromium bug: https://bugs.chromium.org/p/chromium/issues/detail?id=1060788

Oh, that assertion is related to D75036 which I did. I can have a look at that.

I wrote a PR for that: https://bugs.llvm.org/show_bug.cgi?id=45181.

I'll see if I'm able to put together something for that today.

[thakis]

This makes clang crash, repro at https://bugs.chromium.org/p/chromium/issues/detail?id=1061533#c4 I'll revert for now.

I'm also seeing timeouts and use-after-frees on other bots; maybe they're related (or maybe not).

[thakis]

Reduced repro at https://bugs.chromium.org/p/chromium/issues/detail?id=1061533#c7

Scrolling up, it looks like this was reverted yesterday already. I'm confused why this wasn't reverted yesterday; all work I did in bisecting and creducing was a duplicate of what happened yesterday :/

[djtodoro]

Why reverting this one? Is it a different assertion?

The D75036 was the problem with the previous issue reported.

[aprantl]

FYI: See also https://reviews.llvm.org/D76164

[djtodoro]

Since we landed the fix for the issue related to the D75036, I'll reland this again.

[djtodoro]

Re-enabled with the d9b962100942.

If we face a failure again, since this enables the whole feature, I recommend reverting smaller pieces of the feature that was causing the problem, rather than reverting this patch.

[manojgupta]

Still causing a crash using a previously supplied test https://bugs.chromium.org/p/chromium/issues/detail?id=1061533#c7. Any reason this was not tested with a previous repro?

[djtodoro]

Oh sorry, I thought it all has been fixed, since all the tests pass.

We should revert the D75036 until we fix all the issues.

[djtodoro]

In D73534#1933985, @djtodoro wrote:

Oh sorry, I thought it all has been fixed, since all the tests pass.

We should revert the D75036 until we fix all the issues.

@dstenb do you agree?

[vsk]

In D73534#1933988, @djtodoro wrote:

In D73534#1933985, @djtodoro wrote:

Oh sorry, I thought it all has been fixed, since all the tests pass.

We should revert the D75036 until we fix all the issues.

@dstenb do you agree?

This was an oversight on my part, the fix from D76164 was not complete. I need a few more minutes to write a test, but I should be able to fix this very soon. If we can fix-forward, that would be easier.

[djtodoro]

In D73534#1934105, @vsk wrote:

In D73534#1933988, @djtodoro wrote:

In D73534#1933985, @djtodoro wrote:

Oh sorry, I thought it all has been fixed, since all the tests pass.

We should revert the D75036 until we fix all the issues.

@dstenb do you agree?

This was an oversight on my part, the fix from D76164 was not complete. I need a few more minutes to write a test, but I should be able to fix this very soon. If we can fix-forward, that would be easier.

@vsk That would be great. Thanks a lot!

[vsk]

@manojgupta I apologize for not catching this earlier. The issue should really be fixed by 636665331bbd4c369a9f33c4d35fb9a863c94646.

[manojgupta]

Thanks for the quick fix, verified that the crash is fixed on trunk.

clang/include/clang/Basic/CodeGenOptions.def

CODEGENOPT(DisableLLVMPasses , 1, 0) ///< Don't run any LLVM IR passes to get
                                      ///< frontend.
 CODEGENOPT(DisableLifetimeMarkers, 1, 0) ///< Don't emit any lifetime markers
 CODEGENOPT(DisableO0ImplyOptNone , 1, 0) ///< Don't annonate function with optnone at O0
 CODEGENOPT(ExperimentalNewPassManager, 1, 0) ///< Enables the new, experimental
                                              ///< pass manager.
 CODEGENOPT(DebugPassManager, 1, 0) ///< Prints debug information for the new
                                    ///< pass manager.
 CODEGENOPT(DisableRedZone    , 1, 0) ///< Set when -mno-red-zone is enabled.
-CODEGENOPT(EnableDebugEntryValues, 1, 0) ///< Emit call site parameter dbg info
 CODEGENOPT(IndirectTlsSegRefs, 1, 0) ///< Set when -mno-tls-direct-seg-refs
                                      ///< is specified.
 CODEGENOPT(DisableTailCalls  , 1, 0) ///< Do not emit tail calls.
 CODEGENOPT(NoEscapingBlockTailCalls, 1, 0) ///< Do not emit tail calls from
                                            ///< escaping blocks.
 CODEGENOPT(EmitDeclMetadata  , 1, 0) ///< Emit special metadata indicating what
                                      ///< Decl* various IR entities came from.
                                      ///< Only useful when running CodeGen as a

clang/include/clang/Driver/CC1Options.td

def fprofile_instrument_use_path_EQ :
     Joined<["-"], "fprofile-instrument-use-path=">,
     HelpText<"Specify the profile path in PGO use compilation">;
 def flto_visibility_public_std:
     Flag<["-"], "flto-visibility-public-std">,
     HelpText<"Use public LTO visibility for classes in std and stdext namespaces">;
 def flto_unit: Flag<["-"], "flto-unit">,
     HelpText<"Emit IR to support LTO unit features (CFI, whole program vtable opt)">;
 def fno_lto_unit: Flag<["-"], "fno-lto-unit">;
-def femit_debug_entry_values : Flag<["-"], "femit-debug-entry-values">,
-    HelpText<"Enables debug info about call site parameter's entry values">;
 def fdebug_pass_manager : Flag<["-"], "fdebug-pass-manager">,
     HelpText<"Prints debug information for the new pass manager">;
 def fno_debug_pass_manager : Flag<["-"], "fno-debug-pass-manager">,
     HelpText<"Disables debug printing for the new pass manager">;
 // The driver option takes the key as a parameter to the -msign-return-address=
 // and -mbranch-protection= options, but CC1 has a separate option so we
 // don't have to parse the parameter twice.
 def msign_return_address_key_EQ : Joined<["-"], "msign-return-address-key=">,

clang/lib/CodeGen/BackendUtil.cpp

static void initTargetOptions(llvm::TargetOptions &Options,
   Options.DataSections = CodeGenOpts.DataSections;
   Options.UniqueSectionNames = CodeGenOpts.UniqueSectionNames;
   Options.TLSSize = CodeGenOpts.TLSSize;
   Options.EmulatedTLS = CodeGenOpts.EmulatedTLS;
   Options.ExplicitEmulatedTLS = CodeGenOpts.ExplicitEmulatedTLS;
   Options.DebuggerTuning = CodeGenOpts.getDebuggerTuning();
   Options.EmitStackSizeSection = CodeGenOpts.StackSizeSection;
   Options.EmitAddrsig = CodeGenOpts.Addrsig;
-  Options.EnableDebugEntryValues = CodeGenOpts.EnableDebugEntryValues;
   Options.ForceDwarfFrameSection = CodeGenOpts.ForceDwarfFrameSection;
 
   Options.MCOptions.SplitDwarfFile = CodeGenOpts.SplitDwarfFile;
   Options.MCOptions.MCRelaxAll = CodeGenOpts.RelaxAll;
   Options.MCOptions.MCSaveTempLabels = CodeGenOpts.SaveTempLabels;
   Options.MCOptions.MCUseDwarfDirectory = !CodeGenOpts.NoDwarfDirectoryAsm;
   Options.MCOptions.MCNoExecStack = CodeGenOpts.NoExecStack;
   Options.MCOptions.MCIncrementalLinkerCompatible =

clang/lib/CodeGen/CGDebugInfo.cpp

llvm::DINode::DIFlags CGDebugInfo::getCallSiteRelatedAttrs() const {
   // Call site-related attributes are available in DWARF v5. Some debuggers,
   // while not fully DWARF v5-compliant, may accept these attributes as if they
   // were part of DWARF v4.
   bool SupportsDWARFv4Ext =
       CGM.getCodeGenOpts().DwarfVersion == 4 &&
       (CGM.getCodeGenOpts().getDebuggerTuning() == llvm::DebuggerKind::LLDB ||
        CGM.getCodeGenOpts().getDebuggerTuning() == llvm::DebuggerKind::GDB);
 
-  if (!SupportsDWARFv4Ext && CGM.getCodeGenOpts().DwarfVersion < 5 &&
-      !CGM.getCodeGenOpts().EnableDebugEntryValues)
+  if (!SupportsDWARFv4Ext && CGM.getCodeGenOpts().DwarfVersion < 5)
     return llvm::DINode::FlagZero;
 
   return llvm::DINode::FlagAllCallsDescribed;
 }

clang/lib/Frontend/CompilerInvocation.cpp

static bool ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args, InputKind IK,
   }
 
   if (const Arg *A =
           Args.getLastArg(OPT_emit_llvm_uselists, OPT_no_emit_llvm_uselists))
     Opts.EmitLLVMUseLists = A->getOption().getID() == OPT_emit_llvm_uselists;
 
   Opts.DisableLLVMPasses = Args.hasArg(OPT_disable_llvm_passes);
   Opts.DisableLifetimeMarkers = Args.hasArg(OPT_disable_lifetimemarkers);
-
-  const llvm::Triple::ArchType DebugEntryValueArchs[] = {
-      llvm::Triple::x86, llvm::Triple::x86_64, llvm::Triple::aarch64,
-      llvm::Triple::arm, llvm::Triple::armeb};
-
-  llvm::Triple T(TargetOpts.Triple);
-  if (Opts.OptimizationLevel > 0 && Opts.hasReducedDebugInfo() &&
-      llvm::is_contained(DebugEntryValueArchs, T.getArch()))
-    Opts.EnableDebugEntryValues = Args.hasArg(OPT_femit_debug_entry_values);
-
   Opts.DisableO0ImplyOptNone = Args.hasArg(OPT_disable_O0_optnone);
   Opts.DisableRedZone = Args.hasArg(OPT_disable_red_zone);
   Opts.IndirectTlsSegRefs = Args.hasArg(OPT_mno_tls_direct_seg_refs);
   Opts.ForbidGuardVariables = Args.hasArg(OPT_fforbid_guard_variables);
   Opts.UseRegisterSizedBitfieldAccess = Args.hasArg(
     OPT_fuse_register_sized_bitfield_access);
   Opts.RelaxedAliasing = Args.hasArg(OPT_relaxed_aliasing);
   Opts.StructPathTBAA = !Args.hasArg(OPT_no_struct_path_tbaa);

clang/test/CodeGen/debug-info-extern-call.c

 // When entry values are emitted, expect a subprogram for extern decls so that
 // the dwarf generator can describe call site parameters at extern call sites.
 //
-// RUN: %clang -Xclang -femit-debug-entry-values -g -O2 -target x86_64-none-linux-gnu -S -emit-llvm %s -o - \
+// RUN: %clang -g -O2 -target x86_64-none-linux-gnu -S -emit-llvm %s -o - \
 // RUN:   | FileCheck %s -check-prefix=DECLS-FOR-EXTERN
 
 // Similarly, when the debugger tuning is gdb, expect a subprogram for extern
 // decls so that the dwarf generator can describe information needed for tail
 // call frame reconstrution.
 //
 // RUN: %clang -g -O2 -target x86_64-none-linux-gnu -ggdb -S -emit-llvm %s -o - \
 // RUN:   | FileCheck %s -check-prefix=DECLS-FOR-EXTERN

clang/test/CodeGenCXX/dbg-info-all-calls-described.cpp

 // Supported: DWARF4 + LLDB tuning, -O1, limited DI
 // RUN: %clang_cc1 -emit-llvm -triple %itanium_abi_triple %s -o - \
 // RUN:   -O1 -disable-llvm-passes \
 // RUN:   -debugger-tuning=lldb \
 // RUN:   -debug-info-kind=standalone -dwarf-version=4 \
 // RUN: | FileCheck %s -check-prefix=HAS-ATTR \
 // RUN:     -implicit-check-not=DISubprogram -implicit-check-not=DIFlagAllCallsDescribed
 
-// Supported: DWARF4 + GDB tuning by using '-femit-debug-entry-values'
-// RUN: %clang_cc1 -femit-debug-entry-values -emit-llvm -triple x86_64-linux-gnu \
+// Supported: DWARF4 + GDB tuning, -O1
+// RUN: %clang_cc1 -emit-llvm -triple x86_64-linux-gnu \
 // RUN:   %s -o - -O1 -disable-llvm-passes -debugger-tuning=gdb \
 // RUN:   -debug-info-kind=standalone -dwarf-version=4 \
 // RUN: | FileCheck %s -check-prefix=HAS-ATTR \
 // RUN:     -implicit-check-not=DIFlagAllCallsDescribed
 
-// Supported: DWARF4 + LLDB tuning by using '-femit-debug-entry-values'
-// RUN: %clang_cc1 -femit-debug-entry-values -emit-llvm -triple x86_64-linux-gnu \
+// Supported: DWARF4 + LLDB tuning, -O1
+// RUN: %clang_cc1 -emit-llvm -triple x86_64-linux-gnu \
 // RUN:   %s -o - -O1 -disable-llvm-passes -debugger-tuning=lldb \
 // RUN:   -debug-info-kind=standalone -dwarf-version=4 \
 // RUN: | FileCheck %s -check-prefix=HAS-ATTR \
 // RUN:     -implicit-check-not=DIFlagAllCallsDescribed
 
-// Unsupported: -O0 + '-femit-debug-entry-values'
-// RUN: %clang_cc1 -femit-debug-entry-values -emit-llvm -triple x86_64-linux-gnu \
+// Unsupported: -O0
+// RUN: %clang_cc1 -emit-llvm -triple x86_64-linux-gnu \
 // RUN:   %s -o - -O0 -disable-llvm-passes -debugger-tuning=gdb \
 // RUN:   -debug-info-kind=standalone -dwarf-version=4 \
 // RUN: | FileCheck %s -check-prefix=NO-ATTR
 
 // Supported: DWARF4 + LLDB tuning, -O1, line-tables only DI
 // RUN: %clang_cc1 -emit-llvm -triple %itanium_abi_triple %s -o - \
 // RUN:   -O1 -disable-llvm-passes \
 // RUN:   -debugger-tuning=lldb \

lldb/packages/Python/lldbsuite/test/decorators.py

def skipUnlessHasCallSiteInfo(func):
     def is_compiler_clang_with_call_site_info(self):
         compiler_path = self.getCompiler()
         compiler = os.path.basename(compiler_path)
         if not compiler.startswith("clang"):
             return "Test requires clang as compiler"
 
         f = tempfile.NamedTemporaryFile()
         cmd = "echo 'int main() {}' | " \
-              "%s -g -glldb -O1 -Xclang -femit-debug-entry-values -S -emit-llvm -x c -o %s -" % (compiler_path, f.name)
+              "%s -g -glldb -O1 -S -emit-llvm -x c -o %s -" % (compiler_path, f.name)
         if os.popen(cmd).close() is not None:
             return "Compiler can't compile with call site info enabled"
 
         with open(f.name, 'r') as ir_output_file:
             buf = ir_output_file.read()
 
         if 'DIFlagAllCallsDescribed' not in buf:
             return "Compiler did not introduce DIFlagAllCallsDescribed IR flag"

lldb/test/API/functionalities/param_entry_vals/basic_entry_values_x86_64/Makefile

 CXX_SOURCES := main.cpp
-CXXFLAGS_EXTRAS := -O2 -glldb -Xclang -femit-debug-entry-values
+CXXFLAGS_EXTRAS := -O2 -glldb
 include Makefile.rules

llvm/include/llvm/CodeGen/CommandFlags.inc

static cl::opt<bool> EnableStackSizeSection(
     cl::desc("Emit a section containing stack size metadata"), cl::init(false));
 
 static cl::opt<bool>
     EnableAddrsig("addrsig", cl::desc("Emit an address-significance table"),
                   cl::init(false));
 
 static cl::opt<bool>
     EnableDebugEntryValues("debug-entry-values",
-                           cl::desc("Emit debug info about parameter's entry values"),
+                           cl::desc("Enable debug info for the debug entry values"),
                            cl::init(false));
 
 static cl::opt<bool>
     ForceDwarfFrameSection("force-dwarf-frame-section",
                            cl::desc("Always emit a debug frame section."),
                            cl::init(false));
 
 // Common utility function tightly tied to the options listed here. Initializes

llvm/include/llvm/Target/TargetMachine.h

void setGlobalISelAbort(GlobalISelAbortMode Mode) {
     Options.GlobalISelAbort = Mode;
   }
   void setMachineOutliner(bool Enable) {
     Options.EnableMachineOutliner = Enable;
   }
   void setSupportsDefaultOutlining(bool Enable) {
     Options.SupportsDefaultOutlining = Enable;
   }
+  void setSupportsDebugEntryValues(bool Enable) {
+    Options.SupportsDebugEntryValues = Enable;
+  }
 
   bool shouldPrintMachineCode() const { return Options.PrintMachineCode; }
 
   bool getUniqueSectionNames() const { return Options.UniqueSectionNames; }
 
   /// Return true if data objects should be emitted into their own section,
   /// corresponds to -fdata-sections.
   bool getDataSections() const {

llvm/include/llvm/Target/TargetOptions.h

TargetOptions()
           EnableFastISel(false), EnableGlobalISel(false), UseInitArray(false),
           DisableIntegratedAS(false), RelaxELFRelocations(false),
           FunctionSections(false), DataSections(false),
           UniqueSectionNames(true), TrapUnreachable(false),
           NoTrapAfterNoreturn(false), TLSSize(0), EmulatedTLS(false),
           ExplicitEmulatedTLS(false), EnableIPRA(false),
           EmitStackSizeSection(false), EnableMachineOutliner(false),
           SupportsDefaultOutlining(false), EmitAddrsig(false),
-          EnableDebugEntryValues(false), ForceDwarfFrameSection(false) {}
+          SupportsDebugEntryValues(false), EnableDebugEntryValues(false),
+          ForceDwarfFrameSection(false) {}
 
     /// PrintMachineCode - This flag is enabled when the -print-machineinstrs
     /// option is specified on the command line, and should enable debugging
     /// output from the code generator.
     unsigned PrintMachineCode : 1;
 
     /// DisableFramePointerElim - This returns true if frame pointer elimination
     /// optimization should be disabled for the given machine function.
public:
     unsigned EnableMachineOutliner : 1;
 
     /// Set if the target supports default outlining behaviour.
     unsigned SupportsDefaultOutlining : 1;
 
     /// Emit address-significance table.
     unsigned EmitAddrsig : 1;
 
-    /// Emit debug info about parameter's entry values.
+    /// Set if the target supports the debug entry values by default.
+    unsigned SupportsDebugEntryValues : 1;
+    /// When set to true, the EnableDebugEntryValues option forces production
+    /// of debug entry values even if the target does not officially support
+    /// it. Useful for testing purposes only. This flag should never be checked
+    /// directly, always use \ref ShouldEmitDebugEntryValues instead.
     unsigned EnableDebugEntryValues : 1;
+    /// NOTE: There are targets that still do not support the call site info
+    /// production (the info about the arguments passed to the call, necessary
+    /// for the debug entry values), so we keep using the experimental option
+    /// (-debug-entry-values) to test them as well.
+    bool ShouldEmitDebugEntryValues() const;
 
     /// Emit DWARF debug frame section.
     unsigned ForceDwarfFrameSection : 1;
 
     /// FloatABIType - This setting is set by -float-abi=xxx option is specfied
     /// on the command line. This setting may either be Default, Soft, or Hard.
     /// Default selects the target's default behavior. Soft selects the ABI for
     /// software floating point, but does not indicate that FP hardware may not

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.h

class DwarfDebug : public DebugHandlerBase {
   bool HasSplitDwarf;
 
   /// Whether to generate the DWARF v5 string offsets table.
   /// It consists of a series of contributions, each preceded by a header.
   /// The pre-DWARF v5 string offsets table for split dwarf is, in contrast,
   /// a monolithic sequence of string offsets.
   bool UseSegmentedStringOffsetsTable;
 
+  /// Enable production of call site parameters needed to print the debug entry
+  /// values. Useful for testing purposes when a debugger does not support the
+  /// feature yet.
+  bool EmitDebugEntryValues;
+
   /// Separated Dwarf Variables
   /// In general these will all be for bits that are left in the
   /// original object file, rather than things that are meant
   /// to be in the .dwo sections.
 
   /// Holder for the skeleton information.
   DwarfFile SkeletonHolder;
 
public:
   /// DW_FORM_strx* indirect references with DWARF v5 and beyond. Note that
   /// DW_FORM_GNU_str_index is also an indirect reference, but it is used with
   /// a pre-DWARF v5 implementation of split DWARF sections, which uses a
   /// monolithic string offsets table.
   bool useSegmentedStringOffsetsTable() const {
     return UseSegmentedStringOffsetsTable;
   }
 
+  bool emitDebugEntryValues() const {
+    return EmitDebugEntryValues;
+  }
+
   bool shareAcrossDWOCUs() const;
 
   /// Returns the Dwarf Version.
   uint16_t getDwarfVersion() const;
 
   /// Returns the previous CU that was being updated
   const DwarfCompileUnit *getPrevCU() const { return PrevCU; }
   void setPrevCU(const DwarfCompileUnit *PrevCU) { this->PrevCU = PrevCU; }

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

 static cl::opt<bool>
 DisableDebugInfoPrinting("disable-debug-info-print", cl::Hidden,
                          cl::desc("Disable debug info printing"));
 
 static cl::opt<bool> UseDwarfRangesBaseAddressSpecifier(
     "use-dwarf-ranges-base-address-specifier", cl::Hidden,
     cl::desc("Use base address specifiers in debug_ranges"), cl::init(false));
 
+static cl::opt<bool> EmitDwarfDebugEntryValues(
+    "emit-debug-entry-values", cl::Hidden,
+    cl::desc("Emit the debug entry values"), cl::init(false));
+
 static cl::opt<bool> GenerateARangeSection("generate-arange-section",
                                            cl::Hidden,
                                            cl::desc("Generate dwarf aranges"),
                                            cl::init(false));
 
 static cl::opt<bool>
     GenerateDwarfTypeUnits("generate-type-units", cl::Hidden,
                            cl::desc("Generate DWARF4 type units."),
DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
   UseDWARF2Bitfields = (DwarfVersion < 4) || tuneForGDB();
 
   // The DWARF v5 string offsets table has - possibly shared - contributions
   // from each compile and type unit each preceded by a header. The string
   // offsets table used by the pre-DWARF v5 split-DWARF implementation uses
   // a monolithic string offsets table without any header.
   UseSegmentedStringOffsetsTable = DwarfVersion >= 5;
 
+  // Emit call-site-param debug info for GDB and LLDB, if the target supports
+  // the debug entry values feature. It can also be enabled explicitly.
+  EmitDebugEntryValues = (Asm->TM.Options.ShouldEmitDebugEntryValues() &&
+                          (tuneForGDB() || tuneForLLDB())) ||
+                         EmitDwarfDebugEntryValues;
+
   Asm->OutStreamer->getContext().setDwarfVersion(DwarfVersion);
 }
 
 // Define out of line so we don't have to include DwarfUnit.h in DwarfDebug.h.
 DwarfDebug::~DwarfDebug() = default;
 
 static bool isObjCClass(StringRef Name) {
   return Name.startswith("+") || Name.startswith("-");
for (const MachineInstr &MI : MBB.instrs()) {
                                        : StringRef(MF.getSubtarget()
                                                        .getRegisterInfo()
                                                        ->getName(CallReg)))
                         << (IsTail ? " [IsTail]" : "") << "\n");
 
       DIE &CallSiteDIE = CU.constructCallSiteEntryDIE(ScopeDIE, CalleeDIE,
                                                       IsTail, PCAddr, CallReg);
 
-      // GDB and LLDB support call site parameter debug info.
-      if (Asm->TM.Options.EnableDebugEntryValues &&
-          (tuneForGDB() || tuneForLLDB())) {
+      // Optionally emit call-site-param debug info.
+      if (emitDebugEntryValues()) {
         ParamSet Params;
         // Try to interpret values of call site parameters.
         collectCallSiteParameters(&MI, Params);
         CU.constructCallSiteParmEntryDIEs(CallSiteDIE, Params);
       }
     }
   }
 }
 

llvm/lib/CodeGen/LiveDebugValues.cpp

bool AnyRegMaskKillsReg =
         });
     if (AnyRegMaskKillsReg)
       KillSet.set(ID);
   }
   OpenRanges.erase(KillSet, VarLocIDs);
 
   if (auto *TPC = getAnalysisIfAvailable<TargetPassConfig>()) {
     auto &TM = TPC->getTM<TargetMachine>();
-    if (TM.Options.EnableDebugEntryValues)
+    if (TM.Options.ShouldEmitDebugEntryValues())
       emitEntryValues(MI, OpenRanges, VarLocIDs, Transfers, KillSet);
   }
 }
 
 bool LiveDebugValues::isSpillInstruction(const MachineInstr &MI,
                                          MachineFunction *MF) {
   // TODO: Handle multiple stores folded into one.
   if (!MI.hasOneMemOperand())

 /// could be used as backup values. If we loose the track of some unmodified
 /// parameters, the backup values will be used as a primary locations.
 void LiveDebugValues::recordEntryValue(const MachineInstr &MI,
                                        const DefinedRegsSet &DefinedRegs,
                                        OpenRangesSet &OpenRanges,
                                        VarLocMap &VarLocIDs) {
   if (auto *TPC = getAnalysisIfAvailable<TargetPassConfig>()) {
     auto &TM = TPC->getTM<TargetMachine>();
-    if (!TM.Options.EnableDebugEntryValues)
+    if (!TM.Options.ShouldEmitDebugEntryValues())
       return;
   }
 
   DebugVariable V(MI.getDebugVariable(), MI.getDebugExpression(),
                   MI.getDebugLoc()->getInlinedAt());
 
   if (!isEntryValueCandidate(MI, DefinedRegs) ||
       OpenRanges.getEntryValueBackup(V))

llvm/lib/CodeGen/MIRParser/MIRParser.cpp

for (auto YamlCSInfo : YamlMF.CallSitesInfo) {
     MachineFunction::CallSiteInfo CSInfo;
     for (auto ArgRegPair : YamlCSInfo.ArgForwardingRegs) {
       unsigned Reg = 0;
       if (parseNamedRegisterReference(PFS, Reg, ArgRegPair.Reg.Value, Error))
         return error(Error, ArgRegPair.Reg.SourceRange);
       CSInfo.emplace_back(Reg, ArgRegPair.ArgNo);
     }
 
-    if (TM.Options.EnableDebugEntryValues)
+    if (TM.Options.ShouldEmitDebugEntryValues())
       MF.addCallArgsForwardingRegs(&*CallI, std::move(CSInfo));
   }
 
-  if (YamlMF.CallSitesInfo.size() && !TM.Options.EnableDebugEntryValues)
+  if (YamlMF.CallSitesInfo.size() && !TM.Options.ShouldEmitDebugEntryValues())
     return error(Twine("Call site info provided but not used"));
   return false;
 }
 
 bool
 MIRParserImpl::initializeMachineFunction(const yaml::MachineFunction &YamlMF,
                                          MachineFunction &MF) {
   // TODO: Recreate the machine function.

llvm/lib/CodeGen/MachineFunction.cpp

try_next:;
   FilterIds.push_back(0); // terminator
   return FilterID;
 }
 
 MachineFunction::CallSiteInfoMap::iterator
 MachineFunction::getCallSiteInfo(const MachineInstr *MI) {
   assert(MI->isCandidateForCallSiteEntry() &&
          "Call site info refers only to call (MI) candidates");
-
-  if (!Target.Options.EnableDebugEntryValues)
+  if (!Target.Options.ShouldEmitDebugEntryValues())
     return CallSitesInfo.end();
   return CallSitesInfo.find(MI);
 }
 
 void MachineFunction::moveCallSiteInfo(const MachineInstr *Old,
                                        const MachineInstr *New) {
   assert(Old->isCandidateForCallSiteEntry() &&
          "Call site info refers only to call (MI) candidates");
 
   if (!New->isCandidateForCallSiteEntry())
     return eraseCallSiteInfo(Old);

llvm/lib/CodeGen/SelectionDAG/ScheduleDAGSDNodes.cpp

if (Before == BB->end()) {
       // beginning of the block.
       MI = &Emitter.getBlock()->instr_front();
     } else {
       // Return first instruction after the pre-existing instructions.
       MI = &*std::next(Before);
     }
 
     if (MI->isCandidateForCallSiteEntry() &&
-        DAG->getTarget().Options.EnableDebugEntryValues)
+        DAG->getTarget().Options.ShouldEmitDebugEntryValues())
       MF.addCallArgsForwardingRegs(MI, DAG->getSDCallSiteInfo(Node));
 
     return MI;
   };
 
   // If this is the first BB, emit byval parameter dbg_value's.
   if (HasDbg && BB->getParent()->begin() == MachineFunction::iterator(BB)) {
     SDDbgInfo::DbgIterator PDI = DAG->ByvalParmDbgBegin();

llvm/lib/CodeGen/TargetOptionsImpl.cpp

bool TargetOptions::DisableFramePointerElim(const MachineFunction &MF) const {
   llvm_unreachable("unknown frame pointer flag");
 }
 
 /// HonorSignDependentRoundingFPMath - Return true if the codegen must assume
 /// that the rounding mode of the FPU can change from its default.
 bool TargetOptions::HonorSignDependentRoundingFPMath() const {
   return !UnsafeFPMath && HonorSignDependentRoundingFPMathOption;
 }
+
+/// NOTE: There are targets that still do not support the call site info
+/// production (the info about the arguments passed to the call, necessary
+/// for the debug entry values), so we keep using the experimental option
+/// (-debug-entry-values) to test them as well.
+bool TargetOptions::ShouldEmitDebugEntryValues() const {
+  return SupportsDebugEntryValues || EnableDebugEntryValues;
+}

llvm/lib/Target/AArch64/AArch64ISelLowering.cpp

if (VA.isRegLoc()) {
                                     [&VA](MachineFunction::ArgRegPair ArgReg) {
                                       return ArgReg.Reg == VA.getLocReg();
                                     }),
                      CSInfo.end());
       } else {
         RegsToPass.emplace_back(VA.getLocReg(), Arg);
         RegsUsed.insert(VA.getLocReg());
         const TargetOptions &Options = DAG.getTarget().Options;
-        if (Options.EnableDebugEntryValues)
+        if (Options.SupportsDebugEntryValues)
           CSInfo.emplace_back(VA.getLocReg(), i);
       }
     } else {
       assert(VA.isMemLoc());
 
       SDValue DstAddr;
       MachinePointerInfo DstInfo;
 

llvm/lib/Target/AArch64/AArch64InstrInfo.cpp

 
 Optional<RegImmPair> AArch64InstrInfo::isAddImmediate(const MachineInstr &MI,
                                                       Register Reg) const {
   int Sign = 1;
   int64_t Offset = 0;
 
   // TODO: Handle cases where Reg is a super- or sub-register of the
   // destination register.
-  if (Reg != MI.getOperand(0).getReg())
+  const MachineOperand &Op0 = MI.getOperand(0);
+  if (!Op0.isReg() || Reg != Op0.getReg())
     return None;
 
   switch (MI.getOpcode()) {
   default:
     return None;
   case AArch64::SUBWri:
   case AArch64::SUBXri:
   case AArch64::SUBSWri:

llvm/lib/Target/AArch64/AArch64TargetMachine.cpp

if (getOptLevel() <= EnableGlobalISelAtO &&
     setGlobalISelAbort(GlobalISelAbortMode::Disable);
   }
 
   // AArch64 supports the MachineOutliner.
   setMachineOutliner(true);
 
   // AArch64 supports default outlining behaviour.
   setSupportsDefaultOutlining(true);
+
+  // AArch64 supports the debug entry values.
+  setSupportsDebugEntryValues(true);
 }
 
 AArch64TargetMachine::~AArch64TargetMachine() = default;
 
 const AArch64Subtarget *
 AArch64TargetMachine::getSubtargetImpl(const Function &F) const {
   Attribute CPUAttr = F.getFnAttribute("target-cpu");
   Attribute FSAttr = F.getFnAttribute("target-features");

llvm/lib/Target/ARM/ARMBaseInstrInfo.cpp

 Optional<RegImmPair> ARMBaseInstrInfo::isAddImmediate(const MachineInstr &MI,
                                                       Register Reg) const {
   int Sign = 1;
   unsigned Opcode = MI.getOpcode();
   int64_t Offset = 0;
 
   // TODO: Handle cases where Reg is a super- or sub-register of the
   // destination register.
-  if (Reg != MI.getOperand(0).getReg())
+  const MachineOperand &Op0 = MI.getOperand(0);
+  if (!Op0.isReg() || Reg != Op0.getReg())
     return None;
 
   // We describe SUBri or ADDri instructions.
   if (Opcode == ARM::SUBri)
     Sign = -1;
   else if (Opcode != ARM::ADDri)
     return None;
 
   // TODO: Third operand can be global address (usually some string). Since
   //       strings can be relocated we cannot calculate their offsets for
   //       now.
-  if (!MI.getOperand(0).isReg() || !MI.getOperand(1).isReg() ||
-      !MI.getOperand(2).isImm())
+  if (!MI.getOperand(1).isReg() || !MI.getOperand(2).isImm())
     return None;
 
   Offset = MI.getOperand(2).getImm() * Sign;
   return RegImmPair{MI.getOperand(1).getReg(), Offset};
 }
 
 bool llvm::registerDefinedBetween(unsigned Reg,
                                   MachineBasicBlock::iterator From,

llvm/lib/Target/ARM/ARMISelLowering.cpp

if (VA.needsCustom()) {
           Outs[0].VT == MVT::i32) {
         assert(VA.getLocVT() == MVT::i32 &&
                "unexpected calling convention register assignment");
         assert(!Ins.empty() && Ins[0].VT == MVT::i32 &&
                "unexpected use of 'returned'");
         isThisReturn = true;
       }
       const TargetOptions &Options = DAG.getTarget().Options;
-      if (Options.EnableDebugEntryValues)
+      if (Options.SupportsDebugEntryValues)
         CSInfo.emplace_back(VA.getLocReg(), i);
       RegsToPass.push_back(std::make_pair(VA.getLocReg(), Arg));
     } else if (isByVal) {
       assert(VA.isMemLoc());
       unsigned offset = 0;
 
       // True if this byval aggregate will be split between registers
       // and memory.

llvm/lib/Target/ARM/ARMTargetMachine.cpp

else
       this->Options.EABIVersion = EABI::EABI5;
   }
 
   if (TT.isOSBinFormatMachO()) {
     this->Options.TrapUnreachable = true;
     this->Options.NoTrapAfterNoreturn = true;
   }
 
+  // ARM supports the debug entry values.
+  setSupportsDebugEntryValues(true);
+
   initAsmInfo();
 }
 
 ARMBaseTargetMachine::~ARMBaseTargetMachine() = default;
 
 const ARMSubtarget *
 ARMBaseTargetMachine::getSubtargetImpl(const Function &F) const {
   Attribute CPUAttr = F.getFnAttribute("target-cpu");

llvm/lib/Target/X86/X86ISelLowering.cpp

for (unsigned I = 0, OutIndex = 0, E = ArgLocs.size(); I != E;
     if (VA.needsCustom()) {
       assert(VA.getValVT() == MVT::v64i1 &&
              "Currently the only custom case is when we split v64i1 to 2 regs");
       // Split v64i1 value into two registers
       Passv64i1ArgInRegs(dl, DAG, Arg, RegsToPass, VA, ArgLocs[++I], Subtarget);
     } else if (VA.isRegLoc()) {
       RegsToPass.push_back(std::make_pair(VA.getLocReg(), Arg));
       const TargetOptions &Options = DAG.getTarget().Options;
-      if (Options.EnableDebugEntryValues)
+      if (Options.SupportsDebugEntryValues)
         CSInfo.emplace_back(VA.getLocReg(), I);
       if (isVarArg && IsWin64) {
         // Win64 ABI requires argument XMM reg to be copied to the corresponding
         // shadow reg if callee is a varargs function.
         unsigned ShadowReg = 0;
         switch (VA.getLocReg()) {
         case X86::XMM0: ShadowReg = X86::RCX; break;
         case X86::XMM1: ShadowReg = X86::RDX; break;

llvm/lib/Target/X86/X86TargetMachine.cpp

X86TargetMachine::X86TargetMachine(const Target &T, const Triple &TT,
   // the calling function, and TrapUnreachable is an easy way to get that.
   if (TT.isPS4() || TT.isOSBinFormatMachO()) {
     this->Options.TrapUnreachable = true;
     this->Options.NoTrapAfterNoreturn = TT.isOSBinFormatMachO();
   }
 
   setMachineOutliner(true);
 
+  // x86 supports the debug entry values.
+  setSupportsDebugEntryValues(true);
+
   initAsmInfo();
 }
 
 X86TargetMachine::~X86TargetMachine() = default;
 
 const X86Subtarget *
 X86TargetMachine::getSubtargetImpl(const Function &F) const {
   Attribute CPUAttr = F.getFnAttribute("target-cpu");

llvm/test/CodeGen/AArch64/arm64-anyregcc.ll

-; RUN: llc < %s -debug-entry-values -mtriple=arm64-apple-darwin | FileCheck %s
+; RUN: llc < %s -mtriple=arm64-apple-darwin | FileCheck %s
 
 ; Stackmap Header: no constants - 6 callsites
 ; CHECK-LABEL: .section __LLVM_STACKMAPS,__llvm_stackmaps
 ; CHECK-NEXT:  __LLVM_StackMaps:
 ; Header
 ; CHECK-NEXT:   .byte 3
 ; CHECK-NEXT:   .byte 0
 ; CHECK-NEXT:   .short 0

llvm/test/CodeGen/AArch64/arm64-patchpoint.ll

-; RUN: llc -mtriple=arm64-apple-darwin -debug-entry-values -enable-misched=0 -mcpu=cyclone                             < %s | FileCheck %s
-; RUN: llc -mtriple=arm64-apple-darwin -debug-entry-values -enable-misched=0 -mcpu=cyclone -fast-isel -fast-isel-abort=1 < %s | FileCheck %s
+; RUN: llc -mtriple=arm64-apple-darwin -enable-misched=0 -mcpu=cyclone                             < %s | FileCheck %s
+; RUN: llc -mtriple=arm64-apple-darwin -enable-misched=0 -mcpu=cyclone -fast-isel -fast-isel-abort=1 < %s | FileCheck %s
 
 ; Trivial patchpoint codegen
 ;
 define i64 @trivial_patchpoint_codegen(i64 %p1, i64 %p2, i64 %p3, i64 %p4) {
 entry:
 ; CHECK-LABEL: trivial_patchpoint_codegen:
 ; CHECK:       mov  x16, #244834610708480
 ; CHECK-NEXT:  movk x16, #48879, lsl #16

llvm/test/CodeGen/AArch64/arm64-tls-dynamics.ll

 ; Verify the call site info. If the call site info is not
 ; in the valid state, an assert should be triggered.
-; RUN: llc < %s -debug-entry-values -mtriple=arm64-none-linux-gnu -stop-after=machineverifier -relocation-model=pic -aarch64-elf-ldtls-generation=1 < %s
+; RUN: llc < %s -mtriple=arm64-none-linux-gnu -stop-after=machineverifier -relocation-model=pic -aarch64-elf-ldtls-generation=1 < %s
 
 ; RUN: llc -mtriple=arm64-none-linux-gnu -relocation-model=pic -aarch64-elf-ldtls-generation=1 -verify-machineinstrs < %s | FileCheck %s
 ; RUN: llc -mtriple=arm64-none-linux-gnu -relocation-model=pic -aarch64-elf-ldtls-generation=1 -filetype=obj < %s | llvm-objdump -r - | FileCheck --check-prefix=CHECK-RELOC %s
 ; RUN: llc -mtriple=arm64-none-linux-gnu -relocation-model=pic -verify-machineinstrs < %s | FileCheck --check-prefix=CHECK-NOLD %s
 ; RUN: llc -mtriple=arm64-none-linux-gnu -relocation-model=pic -filetype=obj < %s | llvm-objdump -r - | FileCheck --check-prefix=CHECK-NOLD-RELOC %s
 ; FIXME: We currently produce "small" code for the tiny model
 ; RUN: llc -mtriple=arm64-none-linux-gnu -relocation-model=pic -aarch64-elf-ldtls-generation=1 -code-model=tiny -verify-machineinstrs < %s | FileCheck %s
 ; FIXME: We currently error for the large code model

llvm/test/CodeGen/ARM/smml.ll

 ; RUN: llc -mtriple=arm-eabi %s -o - | FileCheck %s -check-prefix=CHECK -check-prefix=CHECK-V4
 ; RUN: llc -mtriple=armv6-eabi %s -o - | FileCheck %s -check-prefix=CHECK -check-prefix=CHECK-V6
 ; RUN: llc -mtriple=armv7-eabi %s -o - | FileCheck %s -check-prefix=CHECK -check-prefix=CHECK-V6
 ; RUN: llc -mtriple=thumb-eabi %s -o - | FileCheck %s -check-prefix=CHECK -check-prefix=CHECK-THUMB
 ; RUN: llc -mtriple=thumbv6-eabi %s -o - | FileCheck %s -check-prefix=CHECK -check-prefix=CHECK-THUMB
 ; RUN: llc -mtriple=thumbv6t2-eabi %s -o - | FileCheck %s -check-prefix=CHECK -check-prefix=CHECK-THUMBV6T2
 ; RUN: llc -mtriple=thumbv7-eabi %s -o - | FileCheck %s -check-prefix=CHECK -check-prefix=CHECK-THUMBV6T2
 ; RUN: llc -mtriple=thumbv7m-eabi %s -o - | FileCheck %s -check-prefix=CHECK -check-prefix=CHECK-V4
 ; RUN: llc -mtriple=thumbv7em-eabi %s -o - | FileCheck %s -check-prefix=CHECK -check-prefix=CHECK-THUMBV6T2
 
 ; Next test would previously trigger an assertion responsible for verification of
 ; call site info state.
-; RUN: llc -stop-after=if-converter -debug-entry-values -mtriple=thumbv6t2-eabi %s -o -| FileCheck %s -check-prefix=CHECK-CALLSITE
+; RUN: llc -stop-after=if-converter -mtriple=thumbv6t2-eabi %s -o -| FileCheck %s -check-prefix=CHECK-CALLSITE
 ; CHECK-CALLSITE: name:  test_used_flags
 ; CHECK-CALLSITE: callSites:
 
 
 define i32 @Test0(i32 %a, i32 %b, i32 %c) nounwind readnone ssp {
 entry:
 ; CHECK-LABEL: Test0
 ; CHECK-NOT: smmls

llvm/test/CodeGen/MIR/Hexagon/bundled-call-site-info.mir

+# We do not support the call site info for the target now, so we use the experimental option (-debug-entry-values).
+
 # RUN: llc -debug-entry-values -run-pass=none -verify-machineinstrs -o - %s | FileCheck %s
 
 # Verify that it is possible to read and write MIR where a callSites entry
 # points to a call residing in a bundle. The offset should point to the call
 # instruction, rather than the bundle head.
 
 # CHECK: name: caller
 # CHECK: callSites:

llvm/test/CodeGen/MIR/X86/call-site-info-error1.mir

-# RUN: not llc -mtriple=x86_64-- -run-pass none -debug-entry-values %s -o - 2>&1 | FileCheck %s
+# RUN: not llc -mtriple=x86_64-- -run-pass none %s -o - 2>&1 | FileCheck %s
 # CHECK: baa call instruction block out of range. Unable to reference bb:1
 --- |
   define dso_local i32 @baa(i32 %a) local_unnamed_addr {
   entry:
     %call = tail call i32 @foo(i32 %a)
     ret i32 %call
   }
 

llvm/test/CodeGen/MIR/X86/call-site-info-error2.mir

-# RUN: not llc -mtriple=x86_64-- -run-pass none -debug-entry-values %s -o - 2>&1 | FileCheck %s
+# RUN: not llc -mtriple=x86_64-- -run-pass none %s -o - 2>&1 | FileCheck %s
 # CHECK: baa call instruction offset out of range. Unable to reference instruction at bb: 0 at offset:1
 --- |
   define dso_local i32 @baa(i32 %a) local_unnamed_addr {
   entry:
     %call = tail call i32 @foo(i32 %a)
     ret i32 %call
   }
 

llvm/test/CodeGen/MIR/X86/call-site-info-error3.mir

-# RUN: not llc -mtriple=x86_64-- -run-pass none -debug-entry-values %s -o - 2>&1 | FileCheck %s
+# RUN: not llc -mtriple=x86_64-- -run-pass none %s -o - 2>&1 | FileCheck %s
 # CHECK: baa call site info should reference call instruction. Instruction at bb:0 at offset:0 is not a call instruction
 --- |
   define dso_local i32 @baa(i32 %a) local_unnamed_addr {
   entry:
     %call = tail call i32 @foo(i32 %a)
     ret i32 %call
   }
 

llvm/test/CodeGen/MIR/X86/call-site-info-error4.mir

-# RUN: not llc -mtriple=x86_64-- -run-pass none %s -o - 2>&1 | FileCheck %s
-# CHECK: Call site info provided but not used
+# RUN: llc -mtriple=x86_64-- -run-pass none %s -o - 2>&1 | FileCheck %s
+# CHECK-NOT: Call site info provided but not used
 --- |
   define dso_local i32 @baa(i32 %a) local_unnamed_addr {
   entry:
     %call = tail call i32 @foo(i32 %a)
     ret i32 %call
   }
 
   declare dso_local i32 @foo(i32) local_unnamed_addr

llvm/test/CodeGen/X86/call-site-info-output.ll

 ; Test call site info MIR printer and parser.Parser assertions and machine
 ; verifier will check the rest;
-; RUN: llc -debug-entry-values %s -stop-before=finalize-isel -o %t.mir
+; RUN: llc %s -stop-before=finalize-isel -o %t.mir
 ; RUN: cat %t.mir | FileCheck %s
 ; CHECK: name: fn2
 ; CHECK: callSites:
 ; There is no need to verify call instruction location since it will be
 ; checked by the MIR parser in the next RUN.
 ; CHECK-NEXT: bb: {{.*}}, offset: {{.*}}, fwdArgRegs:
 ; CHECK-NEXT:   arg: 0, reg: '$edi'
 ; CHECK-NEXT:   arg: 1, reg: '$esi'
 ; CHECK-NEXT:   arg: 2, reg: '$edx'
-; RUN: llc -debug-entry-values %t.mir -run-pass=finalize-isel -o -| FileCheck %s --check-prefix=PARSER
+; RUN: llc %t.mir -run-pass=finalize-isel -o -| FileCheck %s --check-prefix=PARSER
 ; Verify that we are able to parse output mir and that we are getting the same result.
 ; PARSER: name: fn2
 ; PARSER: callSites:
 ; PARSER-NEXT: bb: {{.*}}, offset: {{.*}}, fwdArgRegs:
 ; PARSER-NEXT:   arg: 0, reg: '$edi'
 ; PARSER-NEXT:   arg: 1, reg: '$esi'
 ; PARSER-NEXT:   arg: 2, reg: '$edx'
 

llvm/test/CodeGen/X86/hoist-invariant-load.ll

 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
 
 ; Verify the call site info. If the call site info is not
 ; in the valid state, an assert should be triggered.
-; RUN: llc < %s -debug-entry-values -stop-after=machineverifier
+; RUN: llc < %s -stop-after=machineverifier
 
 ; REQUIRES: asserts
 ; RUN: llc -mcpu=haswell < %s -O2 2>&1 | FileCheck %s
 ; For test:
 ; 2 invariant loads, 1 for OBJC_SELECTOR_REFERENCES_
 ; and 1 for objc_msgSend from the GOT
 ; For test_multi_def:
 ; 2 invariant load (full multiply, both loads should be hoisted.)

llvm/test/CodeGen/X86/speculative-load-hardening-indirect.ll

 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
 
 ; Verify the call site info. If the call site info is not
 ; in the valid state, an assert should be triggered.
-; RUN: llc < %s -debug-entry-values -mtriple=x86_64-unknown-linux-gnu -x86-speculative-load-hardening -stop-after=machineverifier
+; RUN: llc < %s -mtriple=x86_64-unknown-linux-gnu -x86-speculative-load-hardening -stop-after=machineverifier
 
 ; RUN: llc < %s -mtriple=x86_64-unknown-linux-gnu -x86-speculative-load-hardening -data-sections | FileCheck %s --check-prefix=X64
 ; FIXME: Fix machine verifier issues and remove -verify-machineinstrs=0. PR39451.
 ; RUN: llc < %s -mtriple=x86_64-unknown-linux-gnu -x86-speculative-load-hardening -relocation-model pic -data-sections -verify-machineinstrs=0 | FileCheck %s --check-prefix=X64-PIC
 ; RUN: llc < %s -mtriple=x86_64-unknown-linux-gnu -x86-speculative-load-hardening -data-sections -mattr=+retpoline | FileCheck %s --check-prefix=X64-RETPOLINE
 ;
 ; FIXME: Add support for 32-bit.
 

llvm/test/CodeGen/X86/statepoint-allocas.ll

 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
-; RUN: llc -verify-machineinstrs -debug-entry-values < %s | FileCheck %s
+; RUN: llc -verify-machineinstrs < %s | FileCheck %s
 ; Check that we can lower a use of an alloca both as a deopt value (where the
 ; exact meaning is up to the consumer of the stackmap) and as an explicit spill
 ; slot used for GC.
 
 target datalayout = "e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-pc-linux-gnu"
 
 declare zeroext i1 @return_i1()

llvm/test/CodeGen/X86/tail-dup-repeat.ll

 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
-; RUN: llc < %s -mtriple=x86_64-unknown-linux-gnu -debug-entry-values | FileCheck %s
+; RUN: llc < %s -mtriple=x86_64-unknown-linux-gnu | FileCheck %s
 
 ; Function Attrs: uwtable
 ; When tail-duplicating during placement, we work backward from blocks with
 ; multiple successors. In this case, the block dup1 gets duplicated into dup2
 ; and if.then64, and then the block dup2 gets duplicated into land.lhs.true
 ; and if.end70
 
 define void @repeated_tail_dup(i1 %a1, i1 %a2, i32* %a4, i32* %a5, i8* %a6, i32 %a7) #0 align 2 {

llvm/test/CodeGen/X86/xray-custom-log.ll

-; RUN: llc -verify-machineinstrs -debug-entry-values -filetype=asm -o - -mtriple=x86_64-unknown-linux-gnu < %s | FileCheck %s
-; RUN: llc -verify-machineinstrs -debug-entry-values -filetype=asm -o - \
+; RUN: llc -verify-machineinstrs -filetype=asm -o - -mtriple=x86_64-unknown-linux-gnu < %s | FileCheck %s
+; RUN: llc -verify-machineinstrs -filetype=asm -o - \
 ; RUN:     -mtriple=x86_64-unknown-linux-gnu -relocation-model=pic < %s | FileCheck %s -check-prefix=PIC
 
 define i32 @fn() nounwind noinline uwtable "function-instrument"="xray-always" {
     %eventptr = alloca i8
     %eventsize = alloca i32
     store i32 3, i32* %eventsize
     %val = load i32, i32* %eventsize
     call void @llvm.xray.customevent(i8* %eventptr, i32 %val)

llvm/test/CodeGen/X86/xray-typed-event-log.ll

-; RUN: llc -verify-machineinstrs -debug-entry-values -filetype=asm -o - -mtriple=x86_64-unknown-linux-gnu < %s | FileCheck %s
-; RUN: llc -verify-machineinstrs -debug-entry-values -filetype=asm -o - -mtriple=x86_64-unknown-linux-gnu \
+; RUN: llc -verify-machineinstrs -filetype=asm -o - -mtriple=x86_64-unknown-linux-gnu < %s | FileCheck %s
+; RUN: llc -verify-machineinstrs -filetype=asm -o - -mtriple=x86_64-unknown-linux-gnu \
 ; RUN:    -relocation-model=pic < %s | FileCheck %s -check-prefix=PIC
 
 define i32 @fn() nounwind noinline uwtable "function-instrument"="xray-always" {
     %eventptr = alloca i8
     %eventsize = alloca i32
     %eventtype = alloca i16
     store i16 6, i16* %eventtype
     %type = load i16, i16* %eventtype

llvm/test/DebugInfo/AArch64/call-site-info-output.ll

-; RUN: llc -mtriple aarch64-linux-gnu -debug-entry-values %s -o - -stop-before=finalize-isel | FileCheck %s
+; RUN: llc -mtriple aarch64-linux-gnu %s -o - -stop-before=finalize-isel | FileCheck %s
 ; Verify that Selection DAG knows how to recognize simple function parameter forwarding registers.
 ; Produced from:
 ; extern int fn1(int,int,int);
 ; int fn2(int a, int b, int c) {
 ;   int local = fn1(a+b, c, 10);
 ;   if (local > 10)
 ;     return local + 10;
 ;   return local;

llvm/test/DebugInfo/ARM/call-site-info-output.ll

-; RUN: llc -mtriple arm-linux-gnu -debug-entry-values %s -o - -stop-before=finalize-isel | FileCheck %s
+; RUN: llc -mtriple arm-linux-gnu %s -o - -stop-before=finalize-isel | FileCheck %s
 ; Verify that Selection DAG knows how to recognize simple function parameter forwarding registers.
 ; Produced from:
 ; extern int fn1(int,int,int);
 ; int fn2(int a, int b, int c) {
 ;   int local = fn1(a+b, c, 10);
 ;   if (local > 10)
 ;     return local + 10;
 ;   return local;

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

-; RUN: llc -debug-entry-values -filetype=asm -o - %s | FileCheck %s
+; RUN: llc -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;

llvm/test/DebugInfo/MIR/AArch64/dbgcall-site-interpret-movzxi.mir

-# RUN: llc -mtriple aarch64-linux-gnu -debug-entry-values -start-after=machineverifier -filetype=obj %s -o -| llvm-dwarfdump -| FileCheck %s
+# RUN: llc -mtriple aarch64-linux-gnu -start-after=machineverifier -filetype=obj %s -o -| llvm-dwarfdump -| FileCheck %s
 #
 # Based on the following C reproducer:
 #
 # #include <stdint.h>
 #
 # extern void call1(int64_t);
 # extern void call2(int64_t);
 # extern void call3(int64_t);

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

-# RUN: llc -mtriple aarch64-linux-gnu -debug-entry-values -start-after=machineverifier -filetype=obj %s -o -| llvm-dwarfdump -| FileCheck %s
+# RUN: llc -mtriple aarch64-linux-gnu -start-after=machineverifier -filetype=obj %s -o -| llvm-dwarfdump -| FileCheck %s
 # Following code is used for producing this test case. Note that
 # some of argument loading instruction are modified in order to
 # cover certain cases.
 #
 # extern int func2(int,int,int*);
 # int func1(int arg1, int arg2, int arg3) {
 #   int a = func2(arg1 + 2, arg2 - 4, &arg3);
 #   a += func2(arg3 - 16, arg1 + 8, &a);

llvm/test/DebugInfo/MIR/AArch64/dbgcall-site-orr-moves.mir

-# RUN: llc -debug-entry-values -start-after=livedebugvalues -filetype=obj -o - %s | llvm-dwarfdump - | FileCheck %s
+# RUN: llc -start-after=livedebugvalues -filetype=obj -o - %s | llvm-dwarfdump - | FileCheck %s
 
 # Based on the following C reproducer:
 #
 # extern void call_int(int);
 # extern void call_int_int(int, int);
 # extern void call_long(long);
 # extern int global;
 #

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

-# RUN: llc -mtriple=arm-linux-gnueabi -debug-entry-values -filetype=obj -start-after=machineverifier %s -o -| llvm-dwarfdump -| FileCheck %s
+# RUN: llc -mtriple=arm-linux-gnueabi -filetype=obj -start-after=machineverifier %s -o -| llvm-dwarfdump -| FileCheck %s
 # Following code is used for producing this test case. Note that
 # some of argument loading instruction are modified in order to
 # cover certain cases.
 #
 # extern int func2(int,int,int*);
 # int func1(int arg1, int arg2, int arg3) {
 #   int a = func2(arg1 + 2, arg2 - 4, &arg3);
 #   a += func2(arg3 - 16, arg1 + 8, &a);

llvm/test/DebugInfo/MIR/ARM/dbgcall-site-propagated-value.mir

-# RUN: llc -debug-entry-values -run-pass=livedebugvalues -o - %s | FileCheck %s
+# RUN: llc -run-pass=livedebugvalues -o - %s | FileCheck %s
 
 # Based on the following C reproducer:
 #
 # extern void ext(int *);
 # extern int interesting(int *);
 # extern int *value(void);
 #
 # static void callee(int *p1, int *p2) {
 #   if (interesting(p2))
 #     for (;;)
 #       ext(p1);
 #   ext(p2);
 # }
 #
 # void caller() {
 #   int *local = value();
 #   callee(local, (int *)0xabcd);
 # }
 #
 # Generated using:
 #
-# clang -Os -fno-inline -Xclang -femit-debug-entry-values -g --target=armeb.
+# clang -Os -fno-inline -g --target=armeb.
 
 --- |
   target datalayout = "E-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64"
   target triple = "armebv4t-unknown-unknown"
 
   ; Function Attrs: noinline nounwind optsize
   define arm_aapcs_vfpcc void @caller() #0 !dbg !20 {
   entry:

llvm/test/DebugInfo/MIR/ARM/dbgcallsite-noreg-is-imm-check.mir

+# RUN: llc -mtriple=armebv6k-unknown-linux-gnueabihf -filetype=obj -start-after=machineverifier %s -o -| llvm-dwarfdump - | FileCheck %s --implicit-check-not=DW_TAG_GNU_call_site_parameter
+
+## The test was handmade.
+
+--- |
+  ; ModuleID = 'test.c'
+  source_filename = "test.c"
+  target datalayout = "E-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64"
+  target triple = "armebv6k-unknown-linux-gnueabihf"
+  
+  ; Function Attrs: nounwind
+  define dso_local arm_aapcscc i32 @func1(i32 %arg1) local_unnamed_addr !dbg !14 {
+  entry:
+    %add = add nsw i32 %arg1, 2, !dbg !19
+    %a = alloca i32, align 4
+    call void @llvm.dbg.value(metadata i32 %arg1, metadata !18, metadata !DIExpression()), !dbg !19
+    %call = call arm_aapcscc i32 @func2(i32 %add), !dbg !19
+    ret i32  0, !dbg !19
+  }
+  
+  
+  declare !dbg !4 dso_local arm_aapcscc i32 @func2(i32) local_unnamed_addr
+  
+  ; Function Attrs: nounwind readnone speculatable willreturn
+  declare void @llvm.dbg.value(metadata, metadata, metadata)
+  
+  !llvm.dbg.cu = !{!0}
+  !llvm.module.flags = !{!9, !10, !11, !12}
+  !llvm.ident = !{!13}
+  
+  !0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 10.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, retainedTypes: !3, nameTableKind: None)
+  !1 = !DIFile(filename: "test.c", directory: "/")
+  !2 = !{}
+  !3 = !{!4}
+  !4 = !DISubprogram(name: "func2", scope: !1, file: !1, line: 8, type: !5, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !2)
+  !5 = !DISubroutineType(types: !6)
+  !6 = !{!7, !7, !7, !8}
+  !7 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+  !8 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !7, size: 32)
+  !9 = !{i32 2, !"Dwarf Version", i32 4}
+  !10 = !{i32 2, !"Debug Info Version", i32 3}
+  !11 = !{i32 1, !"wchar_size", i32 4}
+  !12 = !{i32 1, !"min_enum_size", i32 4}
+  !13 = !{!"clang version 10.0.0"}
+  !14 = distinct !DISubprogram(name: "func1", scope: !1, file: !1, line: 9, type: !15, scopeLine: 9, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !17)
+  !15 = !DISubroutineType(types: !16)
+  !16 = !{!7, !7, !7, !7}
+  !17 = !{!18}
+  !18 = !DILocalVariable(name: "arg1", arg: 1, scope: !14, file: !1, line: 9, type: !7)
+  !19 = !DILocation(line: 0, scope: !14)
+...
+---
+name:            func1
+alignment:       4
+callSites:
+  - { bb: 0, offset: 11, fwdArgRegs: 
+      - { arg: 0, reg: '$r0' } }
+body:             |
+  bb.0.entry:
+    liveins: $r0, $r1, $r2, $r4, $r10, $lr
+  
+    DBG_VALUE $r0, $noreg, !18, !DIExpression(), debug-location !19
+    $sp = frame-setup STMDB_UPD $sp, 14, $noreg, killed $r4, killed $r10, $r11, killed $lr
+    frame-setup CFI_INSTRUCTION def_cfa_offset 16
+    frame-setup CFI_INSTRUCTION offset $lr, -4
+    frame-setup CFI_INSTRUCTION offset $r11, -8
+    frame-setup CFI_INSTRUCTION offset $r10, -12
+    frame-setup CFI_INSTRUCTION offset $r4, -16
+    $r11 = frame-setup ADDri $sp, 8, 14, $noreg, $noreg
+    frame-setup CFI_INSTRUCTION def_cfa $r11, 8
+    $sp = frame-setup SUBri $sp, 8, 14, $noreg, $noreg
+    INLINEASM &"rev $0, $1", 0, 327690, def renamable $r0, 327689, killed renamable $r4, 0, debug-location !19
+    BL @func2, csr_aapcs, implicit-def dead $lr, implicit $sp, implicit killed $r0, implicit killed $r1, implicit killed $r2, implicit-def $sp, implicit-def $r0, debug-location !19
+    BX_RET 14, $noreg, implicit killed $r0, debug-location !19
+
+...

llvm/test/DebugInfo/MIR/ARM/if-coverter-call-site-info.mir

-# RUN: llc -mtriple=arm-linux-gnu -debug-entry-values -run-pass if-converter %s -o -| FileCheck %s
+# RUN: llc -mtriple=arm-linux-gnu -run-pass if-converter %s -o -| FileCheck %s
 
 # Vefify that the call site info will be updated after the optimization.
 # This test case would previously trigger an assertion when
 # deleting the call instruction.
 
 # Test case is generated from:
 # extern void
 # foo (int* seg, int subseg);
 # extern int* mri_common_symbol;
 #
 # void
 # baa (int* secptr, int subseg)
 # {
 #   if (! (secptr == 0 && subseg == 0))
 #     foo (secptr, subseg);
 #   mri_common_symbol = 0;
 # }
 #
 # With slight change of MIR - substitution of BL instruction with BL_pred 
 # in order to trigger optimization.
-# clang -target arm-linux-gnu -g -O2 -Xclang -femit-debug-entry-values 
-#       %s -stop-before=if-convert
+# clang -target arm-linux-gnu -g -O2 %s -stop-before=if-convert
 #
 # CHECK: callSites:
 # CHECK-NEXT: - { bb: {{.*}}, offset: {{.*}}, fwdArgRegs:
 # CHECK-NEXT:     - { arg: 0, reg: '$r0' }
 # CHECK-NEXT:     - { arg: 1, reg: '$r1' } }
 
 --- |
   ; ModuleID = 'if-convert-call-site-info.c'

llvm/test/DebugInfo/MIR/Hexagon/dbgcall-site-instr-before-bundled-call.mir

-# RUN: llc -mtriple hexagon -debug-entry-values -start-after=machineverifier -filetype=obj %s -o - | llvm-dwarfdump - | FileCheck %s
+# We do not support the call site info for the target now, so we use the experimental option (-debug-entry-values).
+
+# RUN: llc -debug-entry-values -mtriple hexagon -start-after=machineverifier -filetype=obj %s -o - | llvm-dwarfdump - | FileCheck %s
 
 # Based on the following C reproducer:
 #
 # int ga, gb, gc;
 #
 # extern void callee(int, int, int);
 #
 # void caller() {

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

+# We do not support the call site info for the target now, so we use the experimental option (-debug-entry-values).
+
 # RUN: llc -debug-entry-values -run-pass=livedebugvalues -o - %s | FileCheck %s
 
 # Verify that the entry values for the input parameters are inserted after the
 # bundles which contains the registers' clobbering instructions (the calls to
 # @clobber). Previously the insertions would thrash the bundles, later on
 # triggering a crash in DebugHandlerBase.
 
 --- |

llvm/test/DebugInfo/MIR/SystemZ/call-site-lzer.mir

+# We do not support the call site info for the target now, so we use the experimental option (-debug-entry-values).
+
 # RUN: llc -debug-entry-values -start-after=livedebugvalues -o - %s | FileCheck %s
 
 # This test would previously trigger an assertion when trying to describe the
 # call site value for callee()'s float parameter.
 #
 # Please note that at the time of creating this test the SystemZ target did not
 # support call site information, so the "callSites" array has been manually
 # added. For now, verify that we don't crash, and that no (invalid) call site

llvm/test/DebugInfo/MIR/X86/DW_OP_entry_value.mir

-# RUN: llc -debug-entry-values -start-before=livedebugvalues -mtriple=x86_64-apple-darwin -o %t %s -filetype=obj
+# RUN: llc -start-before=livedebugvalues -mtriple=x86_64-apple-darwin -o %t %s -filetype=obj
 # RUN: llvm-dwarfdump %t | FileCheck %s
 #
 # int global;
 # int foo(int p, int q, int r) {
 #   global = p + 1;
 #   asm __volatile("" : : : "edi", "esi", "edx");
 #   return 123;
 # }

llvm/test/DebugInfo/MIR/X86/call-site-gnu-vs-dwarf5-attrs.mir

 # Test the call site encoding in DWARF5 vs GNU extensions.
 #
-# RUN: llc -dwarf-version 4 -debugger-tune=gdb -debug-entry-values -filetype=obj \
+# RUN: llc -dwarf-version 4 -debugger-tune=gdb -filetype=obj \
 # RUN:     -mtriple=x86_64-unknown-unknown -start-after=machineverifier -o - %s  \
 # RUN:     | llvm-dwarfdump - | FileCheck %s -check-prefixes=CHECK-GNU
 #
-# RUN: llc -dwarf-version 5 -debugger-tune=lldb -debug-entry-values -filetype=obj \
+# RUN: llc -dwarf-version 5 -debugger-tune=lldb -filetype=obj \
 # RUN:     -mtriple=x86_64-unknown-unknown -start-after=machineverifier -o - %s   \
 # RUN:     | llvm-dwarfdump - | FileCheck %s -check-prefixes=CHECK-DWARF5
 #
-# RUN: llc -dwarf-version 5 -debug-entry-values -filetype=obj \
+# RUN: llc -dwarf-version 5 -filetype=obj \
+# RUN:     -mtriple=x86_64-unknown-unknown -start-after=machineverifier -o - %s   \
+# RUN:     | llvm-dwarfdump - | FileCheck %s -check-prefixes=CHECK-DWARF5
+#
+# RUN: llc -dwarf-version 5 -filetype=obj -debugger-tune=sce -emit-debug-entry-values \
 # RUN:     -mtriple=x86_64-unknown-unknown -start-after=machineverifier -o - %s   \
 # RUN:     | llvm-dwarfdump - | FileCheck %s -check-prefixes=CHECK-DWARF5
 #
 # This is based on the following reproducer:
 #
 # extern void fn();
 # extern void fn2(int x);
 # extern int fn3();

llvm/test/DebugInfo/MIR/X86/dbg-call-site-spilled-arg-multiple-defs.mir

 # We do not support call site parameters when the machine instructions loading a value
 # into the forwarding register has a memory operand and multiple defs.
 # The generated code was modified a bit in order to have the scenario.
 #
-# RUN: llc -debug-entry-values -start-after=machineverifier -filetype=obj %s -o - \
+# RUN: llc -start-after=machineverifier -filetype=obj %s -o - \
 # RUN:  | llvm-dwarfdump - | FileCheck %s --implicit-check-not=DW_TAG_GNU_call_site_parameter
 #
-# Command: clang -g -O2 -Xclang -femit-debug-entry-values test.c
+# Command: clang -g -O2 test.c
 #          -mllvm -stop-before=machineverifier -o test.mir -c
 # extern void callee(int);
 # extern int y;
 #
 # #define FORCE_SPILL()                                                          \
 #   asm volatile(""                                                              \
 #                :                                                               \
 #                :                                                               \

llvm/test/DebugInfo/MIR/X86/dbg-call-site-spilled-arg.mir

 # Check that llvm can describe a call site parameter which resides in a spill slot.
 #
-# RUN: llc -debug-entry-values -start-after=machineverifier -filetype=obj %s -o - | llvm-dwarfdump - | FileCheck %s
+# RUN: llc -start-after=machineverifier -filetype=obj %s -o - | llvm-dwarfdump - | FileCheck %s
 # 
 # Command:
-# $ ~/src/builds/llvm-project-master-RA/bin/clang -g -Xclang -femit-debug-entry-values -O2 -c -o spill.o spill.cc -mllvm -stop-before=machineverifier -o spill.mir
+# $ ~/src/builds/llvm-project-master-RA/bin/clang -g -O2 -c -o spill.o spill.cc -mllvm -stop-before=machineverifier -o spill.mir
 #
 # Source:
 ## extern void callee(int);
 ## 
 ## #define FORCE_SPILL()                                                          \
 ##   asm volatile(""                                                              \
 ##                :                                                               \
 ##                :                                                               \

llvm/test/DebugInfo/MIR/X86/dbgcall-site-copy-super-sub.mir

-# RUN: llc -debug-entry-values -start-after=livedebugvalues -filetype=obj %s -o -| llvm-dwarfdump -| FileCheck %s
+# RUN: llc -start-after=livedebugvalues -filetype=obj %s -o -| llvm-dwarfdump -| FileCheck %s
 
 # Based on the following reproducer:
 #
 # #include <stdint.h>
 #
 # extern uint32_t value32(void);
 # extern uint64_t value64(void);
 # extern void call32(uint32_t);

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

-# RUN: llc -debug-entry-values -start-after=machineverifier -filetype=obj %s -o -| llvm-dwarfdump -| FileCheck %s
+# RUN: llc -start-after=machineverifier -filetype=obj %s -o -| llvm-dwarfdump -| FileCheck %s
 #
 # CHECK:        DW_TAG_GNU_call_site
 # CHECK-NEXT:     DW_AT_abstract_origin {{.*}} "foo"
 # CHECK-NEXT:     DW_AT_low_pc
 # CHECK-EMPTY:
 # CHECK-NEXT:     DW_TAG_GNU_call_site_parameter
 # CHECK-NEXT:       DW_AT_location      (DW_OP_reg2 RCX)
 # CHECK-NEXT:       DW_AT_GNU_call_site_value   (DW_OP_breg14 R14+0)

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

-# RUN: llc -debug-entry-values -start-after=machineverifier -filetype=obj %s -o -| llvm-dwarfdump -| FileCheck %s
+# RUN: llc -start-after=machineverifier -filetype=obj %s -o -| llvm-dwarfdump -| FileCheck %s
 # CHECK:        DW_TAG_GNU_call_site
 # CHECK-NEXT:     DW_AT_abstract_origin {{.*}} "foo")
 # CHECK-NEXT:     DW_AT_low_pc {{.*}}
 # CHECK-EMPTY:
 # CHECK-NEXT:     DW_TAG_GNU_call_site_parameter
 # CHECK-NEXT:       DW_AT_location      (DW_OP_reg9 R9)
 # CHECK-NEXT:       DW_AT_GNU_call_site_value   (DW_OP_breg15 R15+10)
 # CHECK-EMPTY:

llvm/test/DebugInfo/MIR/X86/dbgcall-site-partial-describe.mir

-# RUN: llc -debug-entry-values -start-before=livedebugvalues -filetype=obj -o - %s \
+# RUN: llc -start-before=livedebugvalues -filetype=obj -o - %s \
 # RUN:     | llvm-dwarfdump - | FileCheck %s --implicit-check-not=DW_TAG_GNU_call_site_parameter
 
 --- |
   target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
   target triple = "x86_64-unknown-linux-gnu"
 
   ; Function Attrs: nounwind uwtable
   define void @foo() #0 !dbg !12 {

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

-# RUN: llc -debug-entry-values -start-before=livedebugvalues -filetype=obj -o - %s | llvm-dwarfdump - | FileCheck %s
+# RUN: llc -start-before=livedebugvalues -filetype=obj -o - %s | llvm-dwarfdump - | FileCheck %s
 
 # Based on the following C++ code:
 # struct A { A(A &) {} };
 # struct B { A a; };
 # struct C { C(B); };
 # struct D : C { D(B); };
 # D::D(B b) : C(b) {}
 

llvm/test/DebugInfo/MIR/X86/dbgcall-site-reg-shuffle.mir

-# RUN: llc -debug-entry-values -start-before=livedebugvalues -filetype=obj -o - %s \
+# RUN: llc -start-before=livedebugvalues -filetype=obj -o - %s \
 # RUN:     | llvm-dwarfdump - | FileCheck %s --implicit-check-not=DW_TAG_GNU_call_site_parameter
 
 --- |
   target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
   target triple = "x86_64-unknown-linux-gnu"
 
   ; Function Attrs: nounwind uwtable
   define void @move_around_args(i32 %a) #0 !dbg !12 {

llvm/test/DebugInfo/MIR/X86/dbgcall-site-two-fwd-reg-defs.mir

-# RUN: llc -O1 -debug-entry-values -start-after=livedebugvalues -filetype=obj %s -o - | llvm-dwarfdump - | FileCheck %s
+# RUN: llc -O1 -start-after=livedebugvalues -filetype=obj %s -o - | llvm-dwarfdump - | FileCheck %s
 
 # Based on the following C reproducer:
 #
 # extern void call(long, int);
 # extern int a, b, c, d;
 #
 # int e() { return a; }
 #

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

-# RUN: llc -debug-entry-values -run-pass=livedebugvalues -march=x86-64 -o - %s | FileCheck %s
+# RUN: llc -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)

llvm/test/DebugInfo/MIR/X86/debug-call-site-param.mir

 # Test call site parameter encoding in DWARFv4.
 # When the debugger tuning is set to gdb, use GNU opcodes.
 # For lldb, use the standard DWARF5 opcodes.
 
-# RUN: llc -debug-entry-values -debugger-tune=gdb -filetype=obj -mtriple=x86_64-unknown-unknown -start-after=machineverifier -o - %s | llvm-dwarfdump - | FileCheck %s -check-prefixes=CHECK-GNU
-# RUN: llc -debug-entry-values -debugger-tune=lldb -filetype=obj -mtriple=x86_64-unknown-unknown -start-after=machineverifier -o - %s | llvm-dwarfdump - | FileCheck %s -check-prefixes=CHECK-DWARF5
+# RUN: llc -debugger-tune=gdb -filetype=obj -mtriple=x86_64-unknown-unknown -start-after=machineverifier -o - %s | llvm-dwarfdump - | FileCheck %s -check-prefixes=CHECK-GNU
+# RUN: llc -debugger-tune=lldb -filetype=obj -mtriple=x86_64-unknown-unknown -start-after=machineverifier -o - %s | llvm-dwarfdump - | FileCheck %s -check-prefixes=CHECK-DWARF5
 #
 # extern void foo(int *a, int b, int c, int d, int e, int f);
 # extern int getVal();
 #
 # void baa(int arg1, int arg2, int arg3) {
 #   int local1 = getVal();
 #   foo(&local1, arg2, 10, 15, arg3 + 3, arg1 + arg2);
 # }

llvm/test/DebugInfo/MIR/X86/entry-value-of-modified-param.mir

-# RUN: llc -debug-entry-values -run-pass=livedebugvalues -march=x86-64 -o - %s | FileCheck %s
+# RUN: llc -run-pass=livedebugvalues -march=x86-64 -o - %s | FileCheck %s
 #
 #extern void fn1 (int, int, int);
 #
 #__attribute__((noinline))
 #int
 #fn2 (int a, int b, int c) {
 #  int q = 2 + a;
 #

llvm/test/DebugInfo/MIR/X86/entry-values-diamond-bbs.mir

-# RUN: llc -debug-entry-values -run-pass=livedebugvalues -march=x86-64 -o - %s | FileCheck %s
+# RUN: llc -run-pass=livedebugvalues -march=x86-64 -o - %s | FileCheck %s
 #
 # The test case was artificially adjusted, in order to make proper diamond basic
 # block structure relevant to the debug entry values propagation.
 #
 # CHECK: ![[ARG_B:.*]] = !DILocalVariable(name: "b"
 # CHECK: bb.0.entry
 # CHECK: DBG_VALUE $esi, $noreg, ![[ARG_B]], !DIExpression()
 # CHECK: bb.1.if.then

llvm/test/DebugInfo/MIR/X86/kill-entry-value-after-diamond-bbs.mir

-# RUN: llc -debug-entry-values -run-pass=livedebugvalues -march=x86-64 -o - %s | FileCheck %s
+# RUN: llc -run-pass=livedebugvalues -march=x86-64 -o - %s | FileCheck %s
 #
 # The test case was artificially adjusted, in order to make proper diamond basic
 # block structure relevant to the debug entry values clobbering.
 #
 # CHECK: ![[ARG_B:.*]] = !DILocalVariable(name: "b"
 # CHECK: bb.0.entry
 # CHECK: DBG_VALUE $esi, $noreg, ![[ARG_B]], !DIExpression()
 # CHECK: bb.1.if.then

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
+# RUN: llc -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;
 #}
 #

llvm/test/DebugInfo/MIR/X86/propagate-entry-value-cross-bbs.mir

-# RUN: llc -debug-entry-values -run-pass=livedebugvalues -march=x86-64 -o - %s | FileCheck %s
+# RUN: llc -run-pass=livedebugvalues -march=x86-64 -o - %s | FileCheck %s
 #
 #extern void fn1 (int, int, int);
 #__attribute__((noinline))
 #int
 #fn2 (int a, int b, int c) {
 #  int q = 2 + a;
 #  fn1 (5, 6, q);
 #  if (b < 17) {

llvm/test/DebugInfo/MIR/X86/unreachable-block-call-site.mir

-# RUN: llc -mtriple=x86_64-pc-linux -debug-entry-values -run-pass=unreachable-mbb-elimination -o - %s | FileCheck %s
+# RUN: llc -mtriple=x86_64-pc-linux -run-pass=unreachable-mbb-elimination -o - %s | FileCheck %s
 
 # Verify that the call site information for the call residing in the eliminated
 # block is removed. This test case would previously trigger an assertion when
 # deleting the call instruction.
 
 # CHECK: name: main
 # CHECK: callSites: []
 

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

+; We do not support the call site info for the target now, so we use the experimental option (-debug-entry-values).
+
 ; 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.

llvm/test/DebugInfo/X86/dbg-value-range.ll

 
 ;CHECK:Ldebug_loc0:
 ;CHECK-NEXT: .set Lset{{.*}},
 ;CHECK-NEXT:  .quad
 ;CHECK-NEXT: .set [[CLOBBER_OFF:Lset.*]], [[CLOBBER]]-{{.*}}
 ;CHECK-NEXT:  .quad [[CLOBBER_OFF]]
 ;CHECK-NEXT:  .short 1 ## Loc expr size
 ;CHECK-NEXT:  .byte 85 ## DW_OP_reg
-;CHECK-NEXT:  .quad 0
+;CHECK:        .quad  0
 ;CHECK-NEXT:  .quad 0
 !24 = !{i32 1, !"Debug Info Version", i32 3}

llvm/test/DebugInfo/X86/dbg-value-regmask-clobber.ll

 ; RUN: llc < %s | FileCheck %s --check-prefix=ASM
 ; RUN: llc < %s -filetype=obj | llvm-dwarfdump - | FileCheck %s --check-prefix=DWARF
 
 ; Values in registers should be clobbered by calls, which use a regmask instead
 ; of individual register def operands.
 
 ; ASM: main: # @main
 ; ASM: #DEBUG_VALUE: main:argc <- $ecx
 ; ASM: movl $1, x(%rip)
 ; ASM: callq clobber
 ; ASM-NEXT: [[argc_range_end:.Ltmp[0-9]+]]:
-; Previously LiveDebugValues would claim argc was still in ecx after the call.
-; ASM-NOT: #DEBUG_VALUE: main:argc
+; ASM: #DEBUG_VALUE: main:argc <- [DW_OP_LLVM_entry_value 1] $ecx
 
 ; argc is the first debug location.
 ; ASM: .Ldebug_loc1:
 ; ASM-NEXT: .quad   .Lfunc_begin0-.Lfunc_begin0
 ; ASM-NEXT: .quad   [[argc_range_end]]-.Lfunc_begin0
 ; ASM-NEXT: .short  1                       # Loc expr size
 ; ASM-NEXT: .byte   82                      # super-register DW_OP_reg2
 
 ; argc is the first formal parameter.
 ; DWARF: .debug_info contents:
 ; DWARF:  DW_TAG_formal_parameter
 ; DWARF-NEXT:    DW_AT_location ({{0x.*}}
-; DWARF-NEXT:      [0x0000000000000000, 0x0000000000000013): DW_OP_reg2 RCX)
+; DWARF-NEXT:    [0x0000000000000000, 0x0000000000000013): DW_OP_reg2 RCX
+; DWARF-NEXT:    [0x0000000000000013, 0x0000000000000043): DW_OP_GNU_entry_value(DW_OP_reg2 RCX), DW_OP_stack_value
 ; DWARF-NEXT:    DW_AT_name ("argc")
 
 ; ModuleID = 't.cpp'
 source_filename = "test/DebugInfo/X86/dbg-value-regmask-clobber.ll"
 target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-pc-windows-msvc18.0.0"
 
 @x = common global i32 0, align 4, !dbg !0

llvm/test/DebugInfo/X86/dbgcall-site-64-bit-imms.ll

-; RUN: llc -O1 -debug-entry-values -filetype=obj -o - %s | llvm-dwarfdump - | FileCheck %s
+; RUN: llc -O1 -filetype=obj -o - %s | llvm-dwarfdump - | FileCheck %s
 
 ; Verify that the 64-bit call site immediates are not truncated.
 ;
 ; Reproducer for PR43525.
 
 ; Based on the following C program:
 ;
 ; #include <stdint.h>

llvm/test/DebugInfo/X86/dbgcall-site-zero-valued-imms.ll

-; RUN: llc -O3 -debug-entry-values -filetype=obj -o - %s | llvm-dwarfdump - | FileCheck %s
+; RUN: llc -O3 -filetype=obj -o - %s | llvm-dwarfdump - | FileCheck %s
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 ; Verify that we produce call site entries for the zero-valued parameters.
 ;
 ; Based on the following reproducer:
 ;

llvm/test/DebugInfo/X86/loclists-dwp.ll

 ;   y();
 ;   asm("" : : : "rdi");
 ; }
 ;
 ; b.cpp:
 ; void b(int i) { asm("" : : : "rdi"); }
 
 ; CHECK:      DW_AT_location [DW_FORM_sec_offset]   (0x00000000
-; CHECK-NEXT: DW_LLE_startx_length (0x0000000000000000, 0x0000000000000006): DW_OP_reg5 RDI)
+; CHECK-NEXT: DW_LLE_startx_length (0x0000000000000000, 0x0000000000000006): DW_OP_reg5 RDI
+; CHECK-NEXT: DW_LLE_startx_length (0x0000000000000001, 0x0000000000000002): DW_OP_GNU_entry_value(DW_OP_reg5 RDI), DW_OP_stack_value)
 
 ; CHECK:      DW_AT_location [DW_FORM_sec_offset]   (0x00000000
-; CHECK-NEXT: DW_LLE_startx_length (0x0000000000000000, 0x0000000000000000): DW_OP_reg5 RDI)
+; CHECK-NEXT: DW_LLE_startx_length (0x0000000000000000, 0x0000000000000000): DW_OP_reg5 RDI
+; CHECK-NEXT: DW_LLE_startx_length (0x0000000000000001, 0x0000000000000001): DW_OP_GNU_entry_value(DW_OP_reg5 RDI), DW_OP_stack_value)
 
 target triple = "x86_64-unknown-linux-gnu"
 
 define dso_local void @_Z1ai(i32 %i) local_unnamed_addr !dbg !7 {
 entry:
   call void @llvm.dbg.value(metadata i32 %i, metadata !12, metadata !DIExpression()), !dbg !13
   tail call void @_Z1yv(), !dbg !14
   tail call void asm sideeffect "", "~{rdi},~{dirflag},~{fpsr},~{flags}"(), !dbg !15, !srcloc !16

llvm/test/DebugInfo/X86/no-entry-values-with-O0.ll

+; RUN: llc -O0  -dwarf-version=5 -debugger-tune=lldb -march=x86-64 -filetype=obj < %s \
+; RUN:  | llvm-dwarfdump - | FileCheck --implicit-check-not=DW_OP_entry_value %s
+; RUN: llc -O0  -dwarf-version=5 -debugger-tune=gdb -march=x86-64 -filetype=obj < %s \
+; RUN:  | llvm-dwarfdump - | FileCheck --implicit-check-not=DW_OP_entry_value %s
+
+; The call-site-params are created iff corresponding DISubprogram contains
+; the AllCallsDescribed DIFlag.
+; CHECK-NOT: DW_TAG_call_site_param
+
+; Genarated with:
+; clang -gdwarf-5 -O0 test.c -S -emit-llvm
+;
+; ModuleID = 'test.c'
+target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+; Function Attrs: noinline nounwind optnone uwtable
+define dso_local void @fn1(i32 %x, i32 %y) !dbg !7 {
+entry:
+  %x.addr = alloca i32, align 4
+  %y.addr = alloca i32, align 4
+  %u = alloca i32, align 4
+  %a = alloca i32, align 4
+  store i32 %x, i32* %x.addr, align 4
+  call void @llvm.dbg.declare(metadata i32* %x.addr, metadata !11, metadata !DIExpression()), !dbg !12
+  store i32 %y, i32* %y.addr, align 4
+  call void @llvm.dbg.declare(metadata i32* %y.addr, metadata !13, metadata !DIExpression()), !dbg !14
+  call void @llvm.dbg.declare(metadata i32* %u, metadata !15, metadata !DIExpression()), !dbg !16
+  %0 = load i32, i32* %x.addr, align 4, !dbg !16
+  %1 = load i32, i32* %y.addr, align 4, !dbg !16
+  %add = add nsw i32 %0, %1, !dbg !16
+  store i32 %add, i32* %u, align 4, !dbg !16
+  %2 = load i32, i32* %x.addr, align 4, !dbg !17
+  %cmp = icmp sgt i32 %2, 1, !dbg !17
+  br i1 %cmp, label %if.then, label %if.else, !dbg !16
+
+if.then:                                          ; preds = %entry
+  %3 = load i32, i32* %u, align 4, !dbg !17
+  %add1 = add nsw i32 %3, 1, !dbg !17
+  store i32 %add1, i32* %u, align 4, !dbg !17
+  br label %if.end, !dbg !17
+
+if.else:                                          ; preds = %entry
+  %4 = load i32, i32* %u, align 4, !dbg !17
+  %add2 = add nsw i32 %4, 2, !dbg !17
+  store i32 %add2, i32* %u, align 4, !dbg !17
+  br label %if.end
+
+if.end:                                           ; preds = %if.else, %if.then
+  call void @llvm.dbg.declare(metadata i32* %a, metadata !19, metadata !DIExpression()), !dbg !16
+  store i32 7, i32* %a, align 4, !dbg !16
+  %5 = load i32, i32* %a, align 4, !dbg !16
+  call void @fn2(i32 %5), !dbg !16
+  %6 = load i32, i32* %u, align 4, !dbg !16
+  %dec = add nsw i32 %6, -1, !dbg !16
+  store i32 %dec, i32* %u, align 4, !dbg !16
+  ret void, !dbg !16
+}
+
+; Function Attrs: nounwind readnone speculatable willreturn
+declare void @llvm.dbg.declare(metadata, metadata, metadata)
+
+declare dso_local void @fn2(i32)
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!3, !4, !5}
+!llvm.ident = !{!6}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 11.0.0", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, splitDebugInlining: false, nameTableKind: None)
+!1 = !DIFile(filename: "test.c", directory: "/")
+!2 = !{}
+!3 = !{i32 7, !"Dwarf Version", i32 5}
+!4 = !{i32 2, !"Debug Info Version", i32 3}
+!5 = !{i32 1, !"wchar_size", i32 4}
+!6 = !{!"clang version 11.0.0"}
+!7 = distinct !DISubprogram(name: "fn1", scope: !1, file: !1, line: 5, type: !8, scopeLine: 5, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !0, retainedNodes: !2)
+!8 = !DISubroutineType(types: !9)
+!9 = !{null, !10, !10}
+!10 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!11 = !DILocalVariable(name: "x", arg: 1, scope: !7, file: !1, line: 5, type: !10)
+!12 = !DILocation(line: 5, column: 10, scope: !7)
+!13 = !DILocalVariable(name: "y", arg: 2, scope: !7, file: !1, line: 5, type: !10)
+!14 = !DILocation(line: 5, column: 17, scope: !7)
+!15 = !DILocalVariable(name: "u", scope: !7, file: !1, line: 6, type: !10)
+!16 = !DILocation(line: 6, column: 7, scope: !7)
+!17 = !DILocation(line: 7, column: 7, scope: !18)
+!18 = distinct !DILexicalBlock(scope: !7, file: !1, line: 7, column: 7)
+!19 = !DILocalVariable(name: "a", scope: !7, file: !1, line: 11, type: !10)

llvm/test/tools/llvm-dwarfdump/X86/locstats.ll

-; RUN: llc -debug-entry-values %s -o - -filetype=obj \
+; RUN: llc %s -o - -filetype=obj \
 ; RUN:   | llvm-dwarfdump -statistics - | FileCheck %s
 ;
 ; CHECK: "entry value scope bytes covered":5
 ; CHECK: "formal params scope bytes total":20
 ; CHECK: "formal params scope bytes covered":20
 ; CHECK: "formal params entry value scope bytes covered":5
 ; CHECK: "vars scope bytes total":90
 ; CHECK: "vars scope bytes covered":60

llvm/test/tools/llvm-dwarfdump/X86/stats-dbg-callsite-info.ll

-; RUN: llc -debug-entry-values %s -o - -filetype=obj \
+; RUN: llc %s -o - -filetype=obj \
 ; RUN:   | llvm-dwarfdump -statistics - | FileCheck %s
 ;
-; The LLVM IR file was generated on this source code by using
-; option '-femit-debug-entry-values'.
-;
 ; extern void foo(int *a, int b, int c, int d, int e, int f);
 ; extern int getVal();
 ;
 ; void baa(int arg1, int arg2, int arg3) {
 ;   int local1 = getVal();
 ;   foo(&local1, arg2, 10, 15, arg3 + 3, arg1 + arg2);
 ; }
 ;

llvm/test/tools/llvm-dwarfdump/X86/valid-call-site-GNU-extensions.ll

-; RUN: llc -debug-entry-values %s -o - -filetype=obj \
+; RUN: llc %s -o - -filetype=obj \
 ; RUN:   | llvm-dwarfdump -verify - | FileCheck %s
 ;
 ; CHECK: No errors.
 ;
 ; The source code of the test case:
 ;
 ;extern int fn1();
 ;extern int fn3(int);

llvm/test/tools/llvm-locstats/locstats.ll

 ; UNSUPPORTED: system-windows
 ; REQUIRES: x86-registered-target
 ; RUN: llc %s -o %t0.o -filetype=obj
 ; RUN: %llvm-locstats %t0.o | FileCheck %s --check-prefix=LOCSTATS
 ;
 ; Test the llvm-locstats output.
 ; LOCSTATS: 0% 0 0%
 ; LOCSTATS: (0%,10%) 0 0%
 ; LOCSTATS: [10%,20%) 0 0%
 ; LOCSTATS: [20%,30%) 1 11%
 ; LOCSTATS: [30%,40%) 0 0%
-; LOCSTATS: [40%,50%) 1 11%
-; LOCSTATS: [50%,60%) 1 11%
-; LOCSTATS: [60%,70%) 1 11%
+; LOCSTATS: [40%,50%) 0 0%
+; LOCSTATS: [50%,60%) 0 0%
+; LOCSTATS: [60%,70%) 3 33%
 ; LOCSTATS: [70%,80%) 0 0%
 ; LOCSTATS: [80%,90%) 2 22%
 ; LOCSTATS: [90%,100%) 1 11%
 ; LOCSTATS: 100% 2 22%
 ;
 ; The source code of the test case:
 ;extern int fn2 (int);
 ;