[CallSiteInfo] Enable the call site info only for -g + optimizations

[djtodoro]

Summary

Emit call site info only in the case of '-g' + 'O>0' level.

[djtodoro]

-Rebasing

[djtodoro]

As I mentioned on D74904, I think it makes sense to avoiding production of call site info in the case of non-debug builds, since it is being used only for Debug Entry Values feature.
The Call Site Info potentially could be used by some other LLVM modules, but if we find such case, we can enable it for that purpose as well.

The separate option makes sense to me, since the Call Site Info is conceptually different thing, and the Debug Entry Values feature just uses the Call Site Info utility.

If this seems reasonable, I will rebase the re-landing of D73534 on top of this.

[dstenb]

One downside with this is that if you compile the compilation unit containing the caller with -O0, and the compilation unit containing the callee with optimizations enabled, it will not be possible to evaluate the entry values in the callee. However, GCC (8.3.0) seems to behave in the same way; at least for the small examples I tried.

llvm/include/llvm/Target/TargetOptions.h

261

Nit: optimize -> optimized

266

What do you think about keeping these as two separate things, and query one of EmitCallSiteInfo / EnableDebugEntryValues at each use? I think that it might make it easier to understand the code if they are treated as separate throughout the compiler rather than being merged here.

[aprantl]

Seems reasonable.

clang/include/clang/Basic/CodeGenOptions.def

68

I think this comment should go into the help text for the command line parameter instead?

[djtodoro]

In D75175#1895627, @dstenb wrote:

One downside with this is that if you compile the compilation unit containing the caller with -O0, and the compilation unit containing the callee with optimizations enabled, it will not be possible to evaluate the entry values in the callee.

Yes, but this will restrict only call-site-info (callSites: MF attribute) production. The DWARF (tags for call_sites and call_site_params) was already controlled by the DISubprogram flag (all-calls-described), so I think with or without this that will be the same?

[djtodoro]

clang/include/clang/Basic/CodeGenOptions.def

68

That sounds good to me. Thanks!

[djtodoro]

llvm/include/llvm/Target/TargetOptions.h

266

It is good idea actually! thanks!

[vsk]

clang/lib/Frontend/CompilerInvocation.cpp

1437

Is this a replacement for the EnableDebugEntryValues codegenopt in clang?

[djtodoro]

clang/lib/Frontend/CompilerInvocation.cpp

1437

It is not a full replacement, since it applies only to the Call Site Info. It could end up acting similar to EnableDebugEntryValues, but it is conceptually different.

But it should go above where the EnableDebugEntryValues was set.

[djtodoro]

-Addressing comments

[djtodoro]

TODO: Rebase relanding of the D73534 on top of this.

[djtodoro]

clang/lib/Frontend/CompilerInvocation.cpp

1437

But I would keep the EnableDebugEntryValue Target option as well, if that was the question.

[vsk]

clang/lib/Frontend/CompilerInvocation.cpp

793

I don't understand how Opts.EnableDebugEntryValues and Opts.EmitCallSiteInfo are different. What is the second option supposed to control, that the first option does not? I thought we could already suppress entry values in llvm at -O0 + -g.

Is EmitCallSiteInfo = false supposed to disable TAG_call_site emission?

[djtodoro]

clang/lib/Frontend/CompilerInvocation.cpp

793

I'll try to describe the difference between Call Site Info and entry values.

Entry values (call-site-params and dbg-values with dw_op_entry_val) are features from debug info. The call-site-params are extension of the call-site (TAG_call_site) debug info. Since the emission of the TAG_call_site was already restricted to -O>0 + -g in the constructCallSiteEntryDIEs() (there is a code checking the existence of the AllCallsDescribed), that implies the collectCallSiteParameters() will be called for that combination only (since it is being called in the constructCallSiteEntryDIEs()). Further on, the collectCallSiteParameters() will call the describeLoadedValue(), which is target-dependent method, and it is implemented only for x86, arm and aarch64 targets at the moment, so we need to restrict the emission of call-site-params only to the targets.

The Call Site Info is utility helping us implementing the entry values. We did not have the information about arguments forwarding (necessary for implementing the describeLoadedValue() by searching for the values loaded into the forwarding registers), so the conclusion was to add such info as MF attribute (callSites:). In addition, there were thoughts the attribute could be used by other places in LLVM, but currently it is being used only by Debug Entry Values feature. My understanding is the MF attribute is different thing to the Debug Entry Values, and we can not restrict the production of such attribute by looking at the Debug Info Metadata (for example by looking at the AllCallsDescribed flag), so that is why I added the additional flag.

Is EmitCallSiteInfo = false supposed to disable TAG_call_site emission?

No, it should restrict only the callSites MF attribute.

[djtodoro]

The rebasing of the D73534 would look like (generated with -U999999):

reland-entry-val-option-by-default.patch1 MBDownload

[djtodoro]

Ping.

[aprantl]

llvm/include/llvm/CodeGen/CommandFlags.inc

280

Let's not use a wording like Currently, it will start looking awkward soon.

"Emit call site debug information, if debug information is enabled."

282

Again, this text can't be in LLVM since it is Clang's decision when to enable this. (At least I'm assuming that it is Clang :-). A different fronted could conceivably make different choices.

[djtodoro]

@aprantl Thanks!

llvm/include/llvm/CodeGen/CommandFlags.inc

282

Yes.. some frontends could have benefits of this even with -O0.. I am moving that into clang's part :)

[djtodoro]

-Addressing comments

[vsk]

Sorry for the delay here.

clang/lib/Frontend/CompilerInvocation.cpp

793

Thanks for explaining, this sgtm.

clang/include/clang/Basic/CodeGenOptions.def

 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(EmitCallSiteInfo, 1, 0) ///< Emit call site info only in the case of
+                                   ///< '-g' + 'O>0' level.
 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/lib/CodeGen/BackendUtil.cpp

static void initTargetOptions(llvm::TargetOptions &Options,
   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.EmitCallSiteInfo = CodeGenOpts.EmitCallSiteInfo;
 
   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 =
       CodeGenOpts.IncrementalLinkerCompatible;

clang/lib/Frontend/CompilerInvocation.cpp

static bool ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args, InputKind IK,
   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()))
+      llvm::is_contained(DebugEntryValueArchs, T.getArch())) {
     Opts.EnableDebugEntryValues = Args.hasArg(OPT_femit_debug_entry_values);
+    Opts.EmitCallSiteInfo = true;
+  }
 
   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);
static bool ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args, InputKind IK,
   Opts.SymbolPartition =
       std::string(Args.getLastArgValue(OPT_fsymbol_partition_EQ));
 
   Opts.ForceAAPCSBitfieldLoad = Args.hasArg(OPT_ForceAAPCSBitfieldLoad);
   return Success;
 }
 
 static void ParseDependencyOutputArgs(DependencyOutputOptions &Opts,
                                       ArgList &Args) {
   Opts.OutputFile = std::string(Args.getLastArgValue(OPT_dependency_file));
   Opts.Targets = Args.getAllArgValues(OPT_MT);
   Opts.IncludeSystemHeaders = Args.hasArg(OPT_sys_header_deps);
   Opts.IncludeModuleFiles = Args.hasArg(OPT_module_file_deps);
   Opts.UsePhonyTargets = Args.hasArg(OPT_MP);
   Opts.ShowHeaderIncludes = Args.hasArg(OPT_H);
   Opts.HeaderIncludeOutputFile =
       std::string(Args.getLastArgValue(OPT_header_include_file));

llvm/include/llvm/CodeGen/CommandFlags.inc

 static cl::opt<bool> EnableStackSizeSection(
     "stack-size-section",
     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> EmitCallSiteInfo(
+    "emit-call-site-info",
+    cl::desc(
+        "Emit call site debug information, if debug information is enabled."),
+    cl::init(false));
+
 static cl::opt<bool>
     EnableDebugEntryValues("debug-entry-values",
                            cl::desc("Emit debug info about parameter's entry values"),
                            cl::init(false));
 
 static cl::opt<bool>
     ForceDwarfFrameSection("force-dwarf-frame-section",
                            cl::desc("Always emit a debug frame section."),
static TargetOptions InitTargetOptionsFromCodeGenFlags() {
   Options.FunctionSections = FunctionSections;
   Options.UniqueSectionNames = UniqueSectionNames;
   Options.TLSSize = TLSSize;
   Options.EmulatedTLS = EmulatedTLS;
   Options.ExplicitEmulatedTLS = EmulatedTLS.getNumOccurrences() > 0;
   Options.ExceptionModel = ExceptionModel;
   Options.EmitStackSizeSection = EnableStackSizeSection;
   Options.EmitAddrsig = EnableAddrsig;
+  Options.EmitCallSiteInfo = EmitCallSiteInfo;
   Options.EnableDebugEntryValues = EnableDebugEntryValues;
   Options.ForceDwarfFrameSection = ForceDwarfFrameSection;
 
   Options.MCOptions = InitMCTargetOptionsFromFlags();
 
   Options.ThreadModel = TMModel;
   Options.EABIVersion = EABIVersion;
   Options.DebuggerTuning = DebuggerTuningOpt;

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) {}
+          EmitCallSiteInfo(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;
 
+    /// The flag enables call site info production. It is used only for debug
+    /// info, and it is restricted only to optimized code. This can be used for
+    /// something else, so that should be controlled in the frontend.
+    unsigned EmitCallSiteInfo : 1;
     /// Emit debug info about parameter's entry values.
     unsigned EnableDebugEntryValues : 1;
 
     /// 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
     /// be used. Such a combination is unfortunately popular (e.g.

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.EmitCallSiteInfo)
       MF.addCallArgsForwardingRegs(&*CallI, std::move(CSInfo));
   }
 
-  if (YamlMF.CallSitesInfo.size() && !TM.Options.EnableDebugEntryValues)
+  if (YamlMF.CallSitesInfo.size() && !TM.Options.EmitCallSiteInfo)
     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:;
   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.EmitCallSiteInfo)
     return CallSitesInfo.end();
   return CallSitesInfo.find(MI);
 }
 
 /// Return the call machine instruction or find a call within bundle.
 static const MachineInstr *getCallInstr(const MachineInstr *MI) {
   if (!MI->isBundle())
     return MI;

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.EmitCallSiteInfo)
       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/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.EmitCallSiteInfo)
           CSInfo.emplace_back(VA.getLocReg(), i);
       }
     } else {
       assert(VA.isMemLoc());
 
       SDValue DstAddr;
       MachinePointerInfo DstInfo;
 

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.EmitCallSiteInfo)
         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/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.EmitCallSiteInfo)
         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/test/CodeGen/MIR/Hexagon/bundled-call-site-info.mir

-# RUN: llc -debug-entry-values -run-pass=none -verify-machineinstrs -o - %s | FileCheck %s
+# RUN: llc -emit-call-site-info -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:
 # CHECK-NEXT: bb: 0, offset: 3, fwdArgRegs:

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 -emit-call-site-info -debug-entry-values %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 -emit-call-site-info -debug-entry-values %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/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 -emit-call-site-info -mtriple aarch64-linux-gnu -debug-entry-values %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 -emit-call-site-info -mtriple arm-linux-gnu -debug-entry-values %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/MIR/AArch64/dbgcall-site-expr-chain.mir

-# RUN: llc -mtriple aarch64-linux-gnu -debug-entry-values -start-after=livedebugvalues -filetype=obj -o - %s \
+# RUN: llc -mtriple aarch64-linux-gnu -emit-call-site-info -debug-entry-values -start-after=livedebugvalues -filetype=obj -o - %s \
 # RUN:     | llvm-dwarfdump - | FileCheck %s --implicit-check-not=DW_TAG_GNU_call_site_parameter
 #
 # Based on the following C reproducer:
 #
 #   extern void call(long, long, long);
 #   extern long global;
 #
 #   long foo() {

llvm/test/DebugInfo/MIR/AArch64/dbgcall-site-expr-entry-value.mir

-# RUN: llc -mtriple aarch64-linux-gnu -debug-entry-values -start-after=livedebugvalues -filetype=obj -o - %s \
+# RUN: llc -mtriple aarch64-linux-gnu -emit-call-site-info -debug-entry-values -start-after=livedebugvalues -filetype=obj -o - %s \
 # RUN:     | llvm-dwarfdump - | FileCheck %s --implicit-check-not=DW_TAG_GNU_call_site_parameter
 #
 # Based on the following C reproducer:
 #
 # extern void call(long, long, long);
 #
 # void entry_value (long param) {
 #   call(param + 222, param - 444, param);

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 -emit-call-site-info -mtriple aarch64-linux-gnu -debug-entry-values -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 -emit-call-site-info -mtriple aarch64-linux-gnu -debug-entry-values -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 -emit-call-site-info -debug-entry-values -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/AArch64/implicit-def-dead-scope.mir

-# RUN: llc -start-after=livedebugvalues -filetype=obj -o - %s \
+# RUN: llc -emit-call-site-info -start-after=livedebugvalues -filetype=obj -o - %s \
 # RUN:   | llvm-dwarfdump -v - | FileCheck %s
 
 # This tests for a crash in DwarfDebug's singular DBG_VALUE range promotion when
 #  encountering an IMPLICIT_DEF in its own lexical scope.
 
 # CHECK: .debug_info contents:
 # CHECK:       DW_TAG_formal_parameter
 # CHECK:       DW_AT_location [DW_FORM_sec_offset]

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

-# RUN: llc -O1 -debug-entry-values -filetype=obj -mtriple thumbv7em-apple-unknown-macho -start-after=machineverifier %s -o %t.o
+# RUN: llc -O1 -emit-call-site-info -debug-entry-values -filetype=obj -mtriple thumbv7em-apple-unknown-macho -start-after=machineverifier %s -o %t.o
 # RUN: llvm-dwarfdump %t.o | FileCheck %s
 
 # Crash test, reduced from:
 #
 # a(float);
 # b(double c) {
 #   d();
 #   a(c);

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

-# RUN: llc -O1 -debug-entry-values -filetype=obj -mtriple thumbv7em-apple-unknown-macho -start-after=machineverifier %s -o %t.o
+# RUN: llc -O1 -emit-call-site-info -debug-entry-values -filetype=obj -mtriple thumbv7em-apple-unknown-macho -start-after=machineverifier %s -o %t.o
 # RUN: llvm-dwarfdump %t.o | FileCheck %s
 
 # Crash test, reduced from:
 #
 # a(double);
 # b(double c) {
 #   d();
 #   a(c);

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 -emit-call-site-info -mtriple=arm-linux-gnueabi -debug-entry-values -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 -emit-call-site-info -debug-entry-values -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) {

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

-# RUN: llc -debug-entry-values -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
+# RUN: llc -emit-call-site-info -debug-entry-values -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"

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 -emit-call-site-info -mtriple=arm-linux-gnu -debug-entry-values -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);

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
+# RUN: llc -mtriple hexagon -emit-call-site-info -debug-entry-values -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

-# RUN: llc -debug-entry-values -run-pass=livedebugvalues -o - %s | FileCheck %s
+# RUN: llc -emit-call-site-info -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.
 
 --- |
   target datalayout = "e-m:e-p:32:32:32-a:0-n16:32-i64:64:64-i32:32:32-i16:16:16-i1:8:8-f32:32:32-f64:64:64-v32:32:32-v64:64:64-v512:512:512-v1024:1024:1024-v2048:2048:2048"

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

-# RUN: llc -debug-entry-values -start-after=livedebugvalues -o - %s | FileCheck %s
+# RUN: llc -emit-call-site-info -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
 # parameter entry is emitted, but later on when call site information is added

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 -emit-call-site-info -debug-entry-values -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 -emit-call-site-info -debug-entry-values -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 -emit-call-site-info -debug-entry-values -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 -emit-call-site-info -debug-entry-values -filetype=obj \
 # 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 -emit-call-site-info -debug-entry-values -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
 #          -mllvm -stop-before=machineverifier -o test.mir -c
 # extern void callee(int);
 # extern int y;
 #
 # #define FORCE_SPILL()                                                          \

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 -emit-call-site-info -debug-entry-values -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
 #
 # Source:
 ## extern void callee(int);
 ## 
 ## #define FORCE_SPILL()                                                          \

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 -emit-call-site-info -debug-entry-values -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 -emit-call-site-info -debug-entry-values -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 -emit-call-site-info -debug-entry-values -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 -emit-call-site-info -debug-entry-values -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 -emit-call-site-info -debug-entry-values -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 -emit-call-site-info -debug-entry-values -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 -emit-call-site-info -debug-entry-values -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 -verify-machineinstrs -march=x86-64 -o - %s | FileCheck %s
+# RUN: llc -emit-call-site-info -debug-entry-values -run-pass=livedebugvalues -verify-machineinstrs -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 -emit-call-site-info -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 -emit-call-site-info -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
 #
 # 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 -emit-call-site-info -debug-entry-values -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 -emit-call-site-info -debug-entry-values -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: ![[ARG_C:.*]] = !DILocalVariable(name: "c"
 # CHECK: ![[ARG_Q:.*]] = !DILocalVariable(name: "q"
 # CHECK: bb.0.entry

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 -emit-call-site-info -debug-entry-values -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 -emit-call-site-info -debug-entry-values -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/X86/dbgcall-site-64-bit-imms.ll

-; RUN: llc -O1 -debug-entry-values -filetype=obj -o - %s | llvm-dwarfdump - | FileCheck %s
+; RUN: llc -O1 -emit-call-site-info -debug-entry-values -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 -emit-call-site-info -debug-entry-values -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/tools/llvm-dwarfdump/X86/stats-dbg-callsite-info.ll

-; RUN: llc -debug-entry-values %s -o - -filetype=obj \
+; RUN: llc -emit-call-site-info -debug-entry-values %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();
 ;