[DebugInfo] Add support for DWARF5 call site-related attributes

[vsk]

Summary

DWARF v5 introduces DW_AT_call_all_calls, a subprogram attribute which
indicates that all calls (both regular and tail) within the subprogram
have call site entries. The information within these call site entries
can be used by a debugger to populate backtraces with synthetic tail
call frames.

Tail calling frames go missing in backtraces because the frame of the
caller is reused by the callee. Call site entries allow a debugger to
reconstruct a sequence of (tail) calls which led from one function to
another. This improves backtrace quality. There are limitations: tail
recursion isn't handled, variables within synthetic frames may not
survive to be inspected, etc. This approach is not novel, see:

https://gcc.gnu.org/wiki/summit2010?action=AttachFile&do=get&target=jelinek.pdf

This patch adds an IR-level flag (DIFlagAllCallsDescribed) which lowers
to DW_AT_call_all_calls. It adds the minimal amount of DWARF generation
support needed to emit standards-compliant call site entries. For easier
deployment, when the debugger tuning is LLDB, the DWARF requirement is
adjusted to v4.

Testing: Apart from check-{llvm, clang}, I built a stage2 RelWithDebInfo
clang binary. Its dSYM passed verification and grew by 1.4% compared to
the baseline. 151,879 call site entries were added.

rdar://42001377

[vsk]

• In constructCallSiteEntryDIE, handle the fact that there may not be a DIE representing the local scope.

[dblaikie]

Do you really want to implement all_calls? It seems like that's going to be difficult and expensive (in size). Looks like you're focussed mostly on the tail call case, so why not aim for all_tail_calls?

& why the special case of only describing the first call site for any given function - I mean, it's a space saving, but is that sustainable (if so, are you thinking about proposing a DWARF change to support this implementation choice?)? If not, what's the benefit in having that feature/quirk in the short term?

(also, in general: what's your use case for this feature? It does seem like a rather expensive feature (in terms of debug info size) & I've not, myself, encountered particular uses/need for it as yet)

[vsk]

In D49887#1177851, @dblaikie wrote:

Do you really want to implement all_calls? It seems like that's going to be difficult and expensive (in size). Looks like you're focussed mostly on the tail call case, so why not aim for all_tail_calls?

Without all_calls, it's not possible to infer a backtrace for certain chains of calls. Consider stopping inside of bar() in this example:

volatile int sink;

void bar() __attribute__((noinline)) {
  sink++; //< foo() does not show up in the backtrace.
}

void foo() __attribute__((noinline)) {
  bar(); //< Tail call.
}

void quux() __attribute__((noinline)) {
  bar(); //< Tail call.
}

int main() __attribute__((disable_tail_calls)) {
  foo(); //< Not a tail call.
  return 0;
}

The physical backtrace looks like:

#0 bar
#1 main

Without a TAG_call_site for 'foo' within 'main', it's not possible to complete the backtrace. The synthetic frame between 'bar' and 'main' could either be 'foo' or 'quux'.

& why the special case of only describing the first call site for any given function - I mean, it's a space saving, but is that sustainable (if so, are you thinking about proposing a DWARF change to support this implementation choice?)? If not, what's the benefit in having that feature/quirk in the short term?

Describing only the first call site for a given callee isn't a long-term solution. The basic problem a debugger needs to solve (as I understand it :) is to find a unique path from one frame to another. To solve this problem in the general case, you'd need a TAG_call_site with both the call target and the return PC (address of the instruction after the call) for every call in the program. The return PC is the extra piece of information that allows a debugger to disambiguate between the multiple call chains which could complete a physical backtrace. That's because a return address is stored in a known location on the stack and can be probed for.

The benefit of having limited TAG_call_site information initially is that it's enough to prototype basic debugger support. The algorithm is: do a DFS on the call graph to find a path from one frame to another, and refuse to create synthetic tail call frames if there's more than one path. This has limitations. For example, this algorithm wouldn't be able to complete the backtrace in the example above. However, I think it'd be useful as a proof-of-concept which we can use to lower-bound debug info bloat and to evaluate backtrace quality improvements.

(also, in general: what's your use case for this feature? It does seem like a rather expensive feature (in terms of debug info size) & I've not, myself, encountered particular uses/need for it as yet)

We have a lot of crash logs from optimized programs to symbolicate. I want this feature to make it easier to read these backtraces, much like inline frames do.

[vsk]

In D49887#1178345, @vsk wrote:

The algorithm is: do a DFS on the call graph to find a path from one frame to another, and refuse to create synthetic tail call frames if there's more than one path. This has limitations. For example, this algorithm wouldn't be able to complete the backtrace in the example above.

Oops! Sorry. It would be able to complete the backtrace in the example I shared.

If, OTOH, there were a call to 'quux' within 'main', *then* it would fail to complete the backtrace.

[probinson]

As a partial and somewhat experimental feature, this should be controlled by a command-line option and off by default.
Even when it's complete it should probably still be under at least a tuning option, unless you can demonstrate the size cost is small.

[vsk]

• Gate call site info on -mllvm -callsite-debuginfo-experimental (off by default).
• Add verifier checks for TAG_call_site. Resolve verifier issues found during stage2 testing.

Here are the dSYM sizes I see in RelWithDebInfo (-O2 -g) stage2 builds of clang:

Build	Total dSYM Size	Subprogram Count	Call Site Entries
Baseline	1,053,275,396 bytes	336,411	0
-callsite-debuginfo-experimental=true	1,066,904,289	343,838	82,399

There's a 1.3% increase in the overall size of the dSYM (13MB). 94% of that increase (12.3MB) is due to a size increase in the .debug_info section. The other 6% is distributed across other debugging sections.

It looks like the bulk of the size increase comes from forward-declarations of subprograms in DW_AT_call_origin. One take-away is that it might be more efficient (albeit non-conformant) to use mangled names inside of DW_AT_call_origin.

I experimented with emitting one TAG_call_site per callsite and found that this roughly doubles the number of entries (to 176,087). If we were to add return PC information to each entry, on net this would just add ~5MB to the final dSYM. This is a lot less than I expected.

[aprantl]

llvm/include/llvm/IR/DebugInfoFlags.def

51

Since this patch is adding a new flag, there should also be a bitcode roundtrip test (llvm-as - | llvm-dis - | llvm-as - | llvm-dis -).

[dblaikie]

In D49887#1179141, @vsk wrote:

• Gate call site info on -mllvm -callsite-debuginfo-experimental (off by default).
• Add verifier checks for TAG_call_site. Resolve verifier issues found during stage2 testing.

Here are the dSYM sizes I see in RelWithDebInfo (-O2 -g) stage2 builds of clang:

Build	Total dSYM Size	Subprogram Count	Call Site Entries
Baseline	1,053,275,396 bytes	336,411	0
-callsite-debuginfo-experimental=true	1,066,904,289	343,838	82,399

There's a 1.3% increase in the overall size of the dSYM (13MB). 94% of that increase (12.3MB) is due to a size increase in the .debug_info section. The other 6% is distributed across other debugging sections.

It looks like the bulk of the size increase comes from forward-declarations of subprograms in DW_AT_call_origin. One take-away is that it might be more efficient (albeit non-conformant) to use mangled names inside of DW_AT_call_origin.

I experimented with emitting one TAG_call_site per callsite and found that this roughly doubles the number of entries (to 176,087). If we were to add return PC information to each entry, on net this would just add ~5MB to the final dSYM. This is a lot less than I expected.

Sounds like it'd be reasonable to implement a standards-conformant mode, then? & if you're going for call_all_calls - the implementation seems simpler (no need for the extra "already used" map) & not too expensive.

[vsk]

I think it makes sense to implement the standards-conformant solution first. I'll update this patch once I have a proof-of-concept on the lldb side.

[vsk]

• Add verifier & bitcode tests, rebase.
• Add complete DWARF generation support for call site entries (i.e, one call site entry per call, DW_AT_call_tail_call emission, and DW_AT_call_return_pc emission).

[vsk]

Dsymutil will need to learn to resolve addresses in DW_AT_call_return_pc. Currently, I think it's skipping over them, which means that lldb can't use them.

[dblaikie]

probably leave this a bit more to @aprantl and @JDevlieghere (figure they can speak more to the LLDB needs/tradeoffs/etc that this is targeting) - but there's a first pass.

clang/lib/CodeGen/CGDebugInfo.cpp

51–55

Notice there aren't many cl::opts in clang - this should instead probably be added as a cc1 option, probably a '-f' option (see if GCC has a flag name for this already you can reuse?). Once it's more than experimental, promoted up to a full driver option that forwards down to a cc1 option, etc.

4371

Rather than taking and returning the flags - maybe just return the flags here and users can OR them with their other flags?

4376–4380

I don't think "full" debug info is the right property here - the difference between "full"/standalone and "limited" is that limited assumes the whole program is built with debug info - so it can expect to find debug info in another translation unit/compile unit to cover needed types, etc.

This doesn't fit under that umbrella - I think it probably needs a separate -f flag and it can default to on when tuning for LLDB potentially.

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

44

I take it this is intended to test that non-defining declarations do /not/ have the DIFlagAllCallsDescribed added? But it looks like this check line doesn't test that it's /not/ present. Perhaps adding a comma at the end to ensure no other flags are being passed in the flags field?

48–67

Are these all interesting? Looks like they're all handled by the same code/aren't uniquely interesting situations, perhaps?

llvm/lib/DebugInfo/DWARF/DWARFVerifier.cpp

222

isSubroutineDIE checks for both DW_TAG_subprogram and DW_TAG_inlined_subroutine. Given this code specifically only wants to check for the latter - perhaps it should do that directly?

239

Not sure how this compares to other parts of the verifier - but I imagine this would be rather noisy if there was debug info with all correct DW_TAG_call_sites, but missing DW_AT_call attribute - a function would have many DW_TAG_call_sites, all generating errors, rather than just the first one in each function?

(but maybe that's not a huge deal? Dunno)

[vsk]

Thanks for your feedback @dblaikie! I've addressed some of it and responded to the rest inline.

• Add dsymutil support for relocating the contents of DW_AT_call_return_pc. Now, these addresses are useful to lldb. @friss & @JDevlieghere I've never looked at dsymutil before, would appreciate any comments you may have here.
• Rebase & address some review comments.

clang/lib/CodeGen/CGDebugInfo.cpp

51–55

I think it'd make sense to add a -cc1/driver option if we wanted users to be able to toggle this functionality on/off. But, I don't think we do.

FWIW, GCC just turns call site info on by default (see https://godbolt.org/g/BrLCTd, note that they use .uleb128 0x2117 for DW_AT_GNU_all_call_sites but it's the same thing). From what I can make of GCC's '-###' output, they have no frontend toggle. I think the view here (which I share) is that call site info is just part of generic debugging support.

It seems prudent/sufficient to gate the llvm support on a temporary cl::opt. We'd remove the cl::opt in short order when https://reviews.llvm.org/D50478 lands.

Wdyt? Is there some use case for having a driver-level I'm just missing?

4371

Sounds good.

4376–4380

Thanks for catching this! Hm, I'm still not sure that we'd need a flag to toggle call site info. ISTM that it'd be appropriate to turn it on under DebugLineTablesOnly, LimitedDebugInfo, and FullDebugInfo. FWIW, GCC enables it at -g{1,2,3}.

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

44

Yes, that's the intent behind the test. I assumed that this would be covered by the -implicit-check-not=DIFlagAllCallsDescribed? Yep:

$ echo "foo foo" | ./bin/FileCheck <(echo "CHECK: foo") -implicit-check-not=foo
command line:1:22: error: CHECK-NOT: excluded string found in input
-implicit-check-not='foo'
                     ^
<stdin>:1:5: note: found here
foo foo

48–67

Good point, this can be trimmed down.

llvm/lib/DebugInfo/DWARF/DWARFVerifier.cpp

239

That's a good point, but I'm not sure it'd be worth doing the extra bookkeeping to prevent that from happening.

[aprantl]

clang/lib/CodeGen/CGDebugInfo.cpp

51–55

Why would someone want to turn this feature off? Does it increase the size by a lot?

[vsk]

clang/lib/CodeGen/CGDebugInfo.cpp

51–55

I measured a 1.4% increase in the size of a RelWithDebInfo stage2 build of clang. This seemed like a reasonable increase to me.

[aprantl]

clang/lib/CodeGen/CGDebugInfo.cpp

51–55

Since this is purely additive I wouldn't even bother with an option for this feature and just enable it by default.

51–55

(if the emitted DWARF version is high enough)

[friss]

The dsymutil part LGTM

[vsk]

• Per Adrian and Paul's feedback, remove the experimental "gating" cl::opt because the size overhead of call site info is low.
• Rebase.

[JDevlieghere]

Hi Vedant, apologies for the delay in reviewing this. I have a few nits inline but otherwise this LGTM!

clang/lib/CodeGen/CGDebugInfo.cpp

4374

Any reason you have extra parenthesis here?

4384

nit: Let's switch those around so we gain short-circuiting for the already computed boolean.

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

555

nit: seems like you could simplify this with a ternary operator.

1353

nit: you could merge these two.

llvm/lib/DebugInfo/DWARF/DWARFVerifier.cpp

216

We tend to return an unsigned for the verifiers. It doesn't really matter much but it's nice for consistency and makes it easy to change if there's ever more than one failures.

[vsk]

@JDevlieghere thanks for the feedback, and no worries!

[vsk]

• Rebase.
• Back out the dsymutil change, as the correct section slide offset can only be applied by the debugger (after things like dylibs are mapped into a process).

[vsk]

Does this look good to land?

[aprantl]

Looks mostly good from my end.

llvm/test/DebugInfo/X86/dwarfdump-callsite-invalid-1.s

2

This test should go into test/tools/llvm-dwarfdump.

[vsk]

• Move a dwarfdump test into test/tools/llvm-dwarfdump.

[aheejin]

llvm/trunk/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

536 ↗

(On Diff #168523)

Sorry for the late question, but is the first operand always the callee in a call instruction? That's not true for WebAssembly, but I'm wondering if WebAssembly is an exception and this holds for all other targets.

[djtodoro]

llvm/trunk/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

536 ↗

(On Diff #168523)

Sorry for the late question, but is the first operand always the callee in a call instruction?

AFAIK, it is true for Intel, Arm, MIPS...

That's not true for WebAssembly, but I'm wondering if WebAssembly is an exception and this holds for all other targets.

If that is the case, we can make a TargetInstr method, e.g. getCallee(), that returns the first operand in general, and override it in the WebAssembly case, right?

[aheejin]

llvm/trunk/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

536 ↗

(On Diff #168523)

Thanks for the reply! We have multiple call instructions and the location of the callee operand differs even among them, so we have getCalleeOp utility method. Adding a general getCallee can be good, but if WebAssembly is the only target that does not satisfy the condition that the callee is the 0th operand, maybe we can add a small hacky if-else here..?

[djtodoro]

llvm/trunk/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

536 ↗

(On Diff #168523)

I see... I think we should keep this code target independent (as far as possible), so I still vote for a TargetInstr method here.

(side note: In addition, there might be some downstream targets that could also have the callee operand at non-0th position, so this will indicate that they need to update that code in order to have proper debug info about call-sites.)

[aheejin]

llvm/trunk/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

536 ↗

(On Diff #168523)

Thanks for the suggestion! I tried that in D102978.

clang/lib/CodeGen/CGDebugInfo.h

private:
   /// anonymous decl and create static variables for them. The first
   /// time this is called it needs to be on a union and then from
   /// there we can have additional unnamed fields.
   llvm::DIGlobalVariableExpression *
   CollectAnonRecordDecls(const RecordDecl *RD, llvm::DIFile *Unit,
                          unsigned LineNo, StringRef LinkageName,
                          llvm::GlobalVariable *Var, llvm::DIScope *DContext);
 
+
+  /// Return a copy of \p Flags with call site-related attributes set, provided
+  /// they are supported and enabled.
+  llvm::DINode::DIFlags
+  setCallSiteRelatedAttrs(llvm::DINode::DIFlags Flags) const;
+
   /// Get the printing policy for producing names for debug info.
   PrintingPolicy getPrintingPolicy() const;
 
   /// Get function name for the given FunctionDecl. If the name is
   /// constructed on demand (e.g., C++ destructor) then the name is
   /// stored on the side.
   StringRef getFunctionName(const FunctionDecl *FD);
 

clang/lib/CodeGen/CGDebugInfo.cpp

 #include "llvm/IR/Intrinsics.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/MD5.h"
 #include "llvm/Support/Path.h"
 using namespace clang;
 using namespace clang::CodeGen;
 
+static llvm::cl::opt<bool> CallSiteDebugInfo(
+    "callsite-debuginfo-experimental", llvm::cl::Hidden,
+    llvm::cl::desc("Emit call site-related debug information (experimental)"),
+    llvm::cl::init(false));
+
 static uint32_t getTypeAlignIfRequired(const Type *Ty, const ASTContext &Ctx) {
   auto TI = Ctx.getTypeInfo(Ty);
   return TI.AlignIsRequired ? TI.Align : 0;
 }
 
 static uint32_t getTypeAlignIfRequired(QualType Ty, const ASTContext &Ctx) {
   return getTypeAlignIfRequired(Ty.getTypePtr(), Ctx);
 }
llvm::DISubprogram *CGDebugInfo::getFunctionFwdDeclOrStub(GlobalDecl GD,
   SmallVector<QualType, 16> ArgTypes;
   if (FD)
     for (const ParmVarDecl *Parm : FD->parameters())
       ArgTypes.push_back(Parm->getType());
   CallingConv CC = FD->getType()->castAs<FunctionType>()->getCallConv();
   QualType FnType = CGM.getContext().getFunctionType(
       FD->getReturnType(), ArgTypes, FunctionProtoType::ExtProtoInfo(CC));
   if (Stub) {
+    Flags = setCallSiteRelatedAttrs(Flags);
     return DBuilder.createFunction(
         DContext, Name, LinkageName, Unit, Line,
         getOrCreateFunctionType(GD.getDecl(), FnType, Unit),
         !FD->isExternallyVisible(),
         /* isDefinition = */ true, 0, Flags, CGM.getLangOpts().Optimize,
         TParamsArray.get(), getFunctionDeclaration(FD));
   }
 
if (!HasDecl || D->isImplicit() || D->hasAttr<ArtificialAttr>()) {
     Flags |= llvm::DINode::FlagArtificial;
     // Artificial functions should not silently reuse CurLoc.
     CurLoc = SourceLocation();
   }
 
   if (CurFuncIsThunk)
     Flags |= llvm::DINode::FlagThunk;
 
+  llvm::DINode::DIFlags FlagsForDef = setCallSiteRelatedAttrs(Flags);
+
   unsigned LineNo = getLineNumber(Loc);
   unsigned ScopeLine = getLineNumber(ScopeLoc);
 
   // FIXME: The function declaration we're constructing here is mostly reusing
   // declarations from CXXMethodDecl and not constructing new ones for arbitrary
   // FunctionDecls. When/if we fix this we can have FDContext be TheCU/null for
   // all subprograms instead of the actual context since subprogram definitions
   // are emitted as CU level entities by the backend.
   llvm::DISubprogram *SP = DBuilder.createFunction(
       FDContext, Name, LinkageName, Unit, LineNo,
       getOrCreateFunctionType(D, FnType, Unit), Fn->hasLocalLinkage(),
-      true /*definition*/, ScopeLine, Flags, CGM.getLangOpts().Optimize,
+      true /*definition*/, ScopeLine, FlagsForDef, CGM.getLangOpts().Optimize,
       TParamsArray.get(), getFunctionDeclaration(D));
   Fn->setSubprogram(SP);
   // We might get here with a VarDecl in the case we're generating
   // code for the initialization of globals. Do not record these decls
   // as they will overwrite the actual VarDecl Decl in the cache.
   if (HasDecl && isa<FunctionDecl>(D))
     DeclCache[D->getCanonicalDecl()].reset(SP);
 

 
 llvm::DebugLoc CGDebugInfo::SourceLocToDebugLoc(SourceLocation Loc) {
   if (LexicalBlockStack.empty())
     return llvm::DebugLoc();
 
   llvm::MDNode *Scope = LexicalBlockStack.back();
   return llvm::DebugLoc::get(getLineNumber(Loc), getColumnNumber(Loc), Scope);
 }
+
+llvm::DINode::DIFlags
+CGDebugInfo::setCallSiteRelatedAttrs(llvm::DINode::DIFlags Flags) const {
+  // This is an opt-in experimental feature.
+  if (!CallSiteDebugInfo)
+    return Flags;
+
+  // Call site-related attributes are only useful in optimized programs, and
+  // should only be emitted when full debug info is desired.
+  if (!CGM.getLangOpts().Optimize ||
+      DebugKind < codegenoptions::FullDebugInfo)
+    return Flags;
+
+  // 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;
+  if (CGM.getCodeGenOpts().DwarfVersion < 5 && !SupportsDWARFv4Ext)
+    return Flags;
+
+  return Flags | llvm::DINode::FlagAllCallsDescribed;
+}

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

+// RUN: %clang_cc1 -mllvm -callsite-debuginfo-experimental=true -emit-llvm -triple %itanium_abi_triple %s -o - \
+// RUN:   -O1 -disable-llvm-passes \
+// RUN:   -dwarf-column-info -debug-info-kind=standalone -dwarf-version=5 \
+// RUN: | FileCheck %s -check-prefix=HAS-ATTR \
+// RUN:     -implicit-check-not=DISubprogram -implicit-check-not=DIFlagAllCallsDescribed
+
+// RUN: %clang_cc1 -mllvm -callsite-debuginfo-experimental=true -emit-llvm -triple %itanium_abi_triple %s -o - \
+// RUN:   -O1 -disable-llvm-passes \
+// RUN:   -debugger-tuning=lldb \
+// RUN:   -dwarf-column-info -debug-info-kind=standalone -dwarf-version=4 \
+// RUN: | FileCheck %s -check-prefix=HAS-ATTR \
+// RUN:     -implicit-check-not=DISubprogram -implicit-check-not=DIFlagAllCallsDescribed
+
+// RUN: %clang_cc1 -mllvm -callsite-debuginfo-experimental=true -emit-llvm -triple %itanium_abi_triple %s -o - \
+// RUN:   -O0 \
+// RUN:   -dwarf-column-info -debug-info-kind=standalone -dwarf-version=5 \
+// RUN: | FileCheck %s -check-prefix=NO-ATTR
+
+// RUN: %clang_cc1 -mllvm -callsite-debuginfo-experimental=true -emit-llvm -triple %itanium_abi_triple %s -o - \
+// RUN:   -O1 -disable-llvm-passes \
+// RUN:   -dwarf-column-info -debug-info-kind=standalone -dwarf-version=4 \
+// RUN: | FileCheck %s -check-prefix=NO-ATTR
+
+// RUN: %clang_cc1 -mllvm -callsite-debuginfo-experimental=true -emit-llvm -triple %itanium_abi_triple %s -o - \
+// RUN:   -O1 -disable-llvm-passes \
+// RUN:   -dwarf-column-info -debug-info-kind=limited -dwarf-version=5 \
+// RUN: | FileCheck %s -check-prefix=NO-ATTR
+
+// RUN: %clang_cc1 -mllvm -callsite-debuginfo-experimental=false -emit-llvm -triple %itanium_abi_triple %s -o - \
+// RUN:   -O1 -disable-llvm-passes \
+// RUN:   -dwarf-column-info -debug-info-kind=standalone -dwarf-version=5 \
+// RUN: | FileCheck %s -check-prefix=NO-ATTR
+
+// NO-ATTR-NOT: FlagAllCallsDescribed
+
+// HAS-ATTR-DAG: DISubprogram(name: "declaration2", {{.*}}, isDefinition: true, {{.*}}, flags: DIFlagPrototyped | DIFlagAllCallsDescribed
+// HAS-ATTR-DAG: DISubprogram(name: "struct1", {{.*}}, isDefinition: false, {{.*}}, flags: DIFlagPrototyped
+// HAS-ATTR-DAG: DISubprogram(name: "struct1", {{.*}}, isDefinition: true, {{.*}}, flags: DIFlagPrototyped | DIFlagAllCallsDescribed
+// HAS-ATTR-DAG: DISubprogram(name: "method1", {{.*}}, isDefinition: true, {{.*}}, flags: DIFlagPrototyped | DIFlagAllCallsDescribed
+// HAS-ATTR-DAG: DISubprogram(name: "method1", {{.*}}, isDefinition: false, {{.*}}, flags: DIFlagPublic | DIFlagPrototyped
+// HAS-ATTR-DAG: DISubprogram(name: "struct2", {{.*}}, isDefinition: false, {{.*}}, flags: DIFlagPrototyped
+// HAS-ATTR-DAG: DISubprogram(name: "struct2", {{.*}}, isDefinition: true, {{.*}}, flags: DIFlagPrototyped | DIFlagAllCallsDescribed
+// HAS-ATTR-DAG: DISubprogram(name: "struct2", {{.*}}, isDefinition: true, {{.*}}, flags: DIFlagPrototyped | DIFlagAllCallsDescribed
+// HAS-ATTR-DAG: DISubprogram(name: "method2", {{.*}}, isDefinition: false, {{.*}}, flags: DIFlagPrototyped
+// HAS-ATTR-DAG: DISubprogram(name: "method2", {{.*}}, isDefinition: true, {{.*}}, flags: DIFlagPrototyped | DIFlagAllCallsDescribed
+// HAS-ATTR-DAG: DISubprogram(name: "force_irgen", {{.*}}, isDefinition: true, {{.*}}, flags: DIFlagPrototyped | DIFlagAllCallsDescribed
+
+void declaration1();
+
+void declaration2();
+
+void declaration2() {}
+
+class class1 {
+public:
+  void method1() {}
+};
+
+struct struct1 {
+  struct1() {}
+  void method2() {}
+};
+
+struct struct2 : struct1 {
+  struct2() : struct1() {}
+};
+
+void __attribute__((optnone)) force_irgen() {
+  declaration1();
+  class1().method1();
+  struct2().method2();
+}

llvm/include/llvm/DebugInfo/DWARF/DWARFVerifier.h

private:
   ///
   /// This function currently verifies:
   ///  - The debug info attributes.
   ///  - The debug info form=s.
   ///  - The presence of a root DIE.
   ///  - That the root DIE is a unit DIE.
   ///  - If a unit type is provided, that the unit DIE matches the unit type.
   ///  - The DIE ranges.
+  ///  - That call site entries are only nested within subprograms with a
+  ///    DW_AT_call attribute.
   ///
   /// \param Unit      The DWARF Unit to verify.
   /// \param UnitType  An optional unit type which will be used to verify the
   ///                  type of the unit DIE.
   ///
   /// \returns The number of errors that occurred during verification.
   unsigned verifyUnitContents(DWARFUnit &Unit, uint8_t UnitType = 0);
 
   /// Verifies the unit headers and contents in a .debug_info or .debug_types
   /// section.
   ///
   /// \param S           The DWARF Section to verify.
   /// \param SectionKind The object-file section kind that S comes from.
   ///
   /// \returns The number of errors that occurred during verification.
   unsigned verifyUnitSection(const DWARFSection &S,
                              DWARFSectionKind SectionKind);
 
+  /// Verifies that a call site entry is nested within a subprogram with a
+  /// DW_AT_call attribute.
+  ///
+  /// \returns true if \p Die is either not a call site entry or is a valid one.
+  bool verifyDebugInfoCallSite(const DWARFDie &Die);
+
   /// Verify that all Die ranges are valid.
   ///
   /// This function currently checks for:
   /// - cases in which lowPC >= highPC
   ///
   /// \returns Number of errors that occurred during verification.
   unsigned verifyDieRanges(const DWARFDie &Die, DieRangeInfo &ParentRI);
 

llvm/include/llvm/IR/DebugInfoFlags.def

 HANDLE_DI_FLAG((1 << 19), BitField)
 HANDLE_DI_FLAG((1 << 20), NoReturn)
 HANDLE_DI_FLAG((1 << 21), MainSubprogram)
 HANDLE_DI_FLAG((1 << 22), TypePassByValue)
 HANDLE_DI_FLAG((1 << 23), TypePassByReference)
 HANDLE_DI_FLAG((1 << 24), FixedEnum)
 HANDLE_DI_FLAG((1 << 25), Thunk)
 HANDLE_DI_FLAG((1 << 26), Trivial)
+HANDLE_DI_FLAG((1 << 27), AllCallsDescribed)
 
 // To avoid needing a dedicated value for IndirectVirtualBase, we use
 // the bitwise or of Virtual and FwdDecl, which does not otherwise
 // make sense for inheritance.
 HANDLE_DI_FLAG((1 << 2) | (1 << 5), IndirectVirtualBase)
 
 #ifdef DI_FLAG_LARGEST_NEEDED
 // intended to be used with ADT/BitmaskEnum.h
 // NOTE: always must be equal to largest flag, check this when adding new flag
-HANDLE_DI_FLAG((1 << 26), Largest)
+HANDLE_DI_FLAG((1 << 27), Largest)
 #undef DI_FLAG_LARGEST_NEEDED
 #endif
 
 #undef HANDLE_DI_FLAG

llvm/include/llvm/IR/DebugInfoMetadata.h

public:
   bool isProtected() const {
     return (getFlags() & FlagAccessibility) == FlagProtected;
   }
   bool isPublic() const {
     return (getFlags() & FlagAccessibility) == FlagPublic;
   }
   bool isExplicit() const { return getFlags() & FlagExplicit; }
   bool isPrototyped() const { return getFlags() & FlagPrototyped; }
+  bool areAllCallsDescribed() const {
+    return getFlags() & FlagAllCallsDescribed;
+  }
   bool isMainSubprogram() const { return getFlags() & FlagMainSubprogram; }
 
   /// Check if this is reference-qualified.
   ///
   /// Return true if this subprogram is a C++11 reference-qualified non-static
   /// member function (void foo() &).
   bool isLValueReference() const { return getFlags() & FlagLValueReference; }
 

llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.h

DIE *constructVariableDIE(DbgVariable &DV, const LexicalScope &Scope,
                             DIE *&ObjectPointer);
 
   /// A helper function to create children of a Scope DIE.
   DIE *createScopeChildrenDIE(LexicalScope *Scope,
                               SmallVectorImpl<DIE *> &Children,
                               bool *HasNonScopeChildren = nullptr);
 
   /// Construct a DIE for this subprogram scope.
-  void constructSubprogramScopeDIE(const DISubprogram *Sub, LexicalScope *Scope);
+  DIE &constructSubprogramScopeDIE(const DISubprogram *Sub,
+                                   LexicalScope *Scope);
 
   DIE *createAndAddScopeChildren(LexicalScope *Scope, DIE &ScopeDIE);
 
   void constructAbstractSubprogramScopeDIE(LexicalScope *Scope);
 
+  /// Construct a call site entry DIE describing a call within \p Scope to a
+  /// callee described by \p CalleeSP. \p IsTail specifies whether the call is
+  /// a tail call. \p ReturnPC must be non-null for non-tail calls and point
+  /// to the PC value after the call returns.
+  DIE &constructCallSiteEntryDIE(DIE &ScopeDIE, const DISubprogram &CalleeSP,
+                                 bool IsTail, const MCSymbol *ReturnPC);
+
   /// Construct import_module DIE.
   DIE *constructImportedEntityDIE(const DIImportedEntity *Module);
 
   void finishSubprogramDefinition(const DISubprogram *SP);
   void finishVariableDefinition(const DbgVariable &Var);
 
   /// Find abstract variable associated with Var.
   using InlinedVariable = DbgValueHistoryMap::InlinedVariable;

llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

if (HasNonScopeChildren)
     *HasNonScopeChildren = !Children.empty();
 
   for (LexicalScope *LS : Scope->getChildren())
     constructScopeDIE(LS, Children);
 
   return ObjectPointer;
 }
 
-void DwarfCompileUnit::constructSubprogramScopeDIE(const DISubprogram *Sub, LexicalScope *Scope) {
+DIE &DwarfCompileUnit::constructSubprogramScopeDIE(const DISubprogram *Sub,
+                                                   LexicalScope *Scope) {
   DIE &ScopeDIE = updateSubprogramScopeDIE(Sub);
 
   if (Scope) {
     assert(!Scope->getInlinedAt());
     assert(!Scope->isAbstractScope());
     // Collect lexical scope children first.
     // ObjectPointer might be a local (non-argument) local variable if it's a
     // block's synthetic this pointer.
     if (DIE *ObjectPointer = createAndAddScopeChildren(Scope, ScopeDIE))
       addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer, *ObjectPointer);
   }
 
   // If this is a variadic function, add an unspecified parameter.
   DITypeRefArray FnArgs = Sub->getType()->getTypeArray();
 
   // If we have a single element of null, it is a function that returns void.
   // If we have more than one elements and the last one is null, it is a
   // variadic function.
   if (FnArgs.size() > 1 && !FnArgs[FnArgs.size() - 1] &&
       !includeMinimalInlineScopes())
     ScopeDIE.addChild(
         DIE::get(DIEValueAllocator, dwarf::DW_TAG_unspecified_parameters));
+
+  return ScopeDIE;
 }
 
 DIE *DwarfCompileUnit::createAndAddScopeChildren(LexicalScope *Scope,
                                                  DIE &ScopeDIE) {
   // We create children when the scope DIE is not null.
   SmallVector<DIE *, 8> Children;
   DIE *ObjectPointer = createScopeChildrenDIE(Scope, Children);
 
void DwarfCompileUnit::constructAbstractSubprogramScopeDIE(
   ContextCU->applySubprogramAttributesToDefinition(SP, *AbsDef);
 
   if (!ContextCU->includeMinimalInlineScopes())
     ContextCU->addUInt(*AbsDef, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined);
   if (DIE *ObjectPointer = ContextCU->createAndAddScopeChildren(Scope, *AbsDef))
     ContextCU->addDIEEntry(*AbsDef, dwarf::DW_AT_object_pointer, *ObjectPointer);
 }
 
+DIE &DwarfCompileUnit::constructCallSiteEntryDIE(DIE &ScopeDIE,
+                                                 const DISubprogram &CalleeSP,
+                                                 bool IsTail,
+                                                 const MCSymbol *ReturnPC) {
+  // Insert a call site entry DIE within ScopeDIE.
+  DIE &CallSiteDIE =
+      createAndAddDIE(dwarf::DW_TAG_call_site, ScopeDIE, nullptr);
+
+  // For the purposes of showing tail call frames in backtraces, a key piece of
+  // information is DW_AT_call_origin, a pointer to the callee DIE.
+  DIE *CalleeDIE = getOrCreateSubprogramDIE(&CalleeSP);
+  assert(CalleeDIE && "Could not create DIE for call site entry origin");
+  addDIEEntry(CallSiteDIE, dwarf::DW_AT_call_origin, *CalleeDIE);
+
+  if (IsTail) {
+    // Attach DW_AT_call_tail_call to tail calls for standards compliance.
+    addFlag(CallSiteDIE, dwarf::DW_AT_call_tail_call);
+  } else {
+    // Attach the return PC to allow the debugger to disambiguate call paths
+    // from one function to another.
+    assert(ReturnPC && "Missing return PC information for a call");
+    addLabelAddress(CallSiteDIE, dwarf::DW_AT_call_return_pc, ReturnPC);
+  }
+  return CallSiteDIE;
+}
+
 DIE *DwarfCompileUnit::constructImportedEntityDIE(
     const DIImportedEntity *Module) {
   DIE *IMDie = DIE::get(DIEValueAllocator, (dwarf::Tag)Module->getTag());
   insertDIE(Module, IMDie);
   DIE *EntityDie;
   auto *Entity = resolve(Module->getEntity());
   if (auto *NS = dyn_cast<DINamespace>(Entity))
     EntityDie = getOrCreateNameSpace(NS);

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.h

void ensureAbstractVariableIsCreatedIfScoped(DwarfCompileUnit &CU, InlinedVariable IV,
                                                const MDNode *Scope);
 
   DbgVariable *createConcreteVariable(DwarfCompileUnit &TheCU,
                                       LexicalScope &Scope, InlinedVariable IV);
 
   /// Construct a DIE for this abstract scope.
   void constructAbstractSubprogramScopeDIE(DwarfCompileUnit &SrcCU, LexicalScope *Scope);
 
+  /// Construct DIEs for call site entries describing the calls in \p MF.
+  void constructCallSiteEntryDIEs(const DISubprogram &SP, DwarfCompileUnit &CU,
+                                  DIE &ScopeDIE, const MachineFunction &MF);
+
   template <typename DataT>
   void addAccelNameImpl(AccelTable<DataT> &AppleAccel, StringRef Name,
                         const DIE &Die);
 
   void finishVariableDefinitions();
 
   void finishSubprogramDefinitions();
 

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

 #include "llvm/CodeGen/AsmPrinter.h"
 #include "llvm/CodeGen/DIE.h"
 #include "llvm/CodeGen/LexicalScopes.h"
 #include "llvm/CodeGen/MachineBasicBlock.h"
 #include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/CodeGen/MachineInstr.h"
 #include "llvm/CodeGen/MachineModuleInfo.h"
 #include "llvm/CodeGen/MachineOperand.h"
+#include "llvm/CodeGen/TargetInstrInfo.h"
 #include "llvm/CodeGen/TargetRegisterInfo.h"
 #include "llvm/CodeGen/TargetSubtargetInfo.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DebugInfoMetadata.h"
 #include "llvm/IR/DebugLoc.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/GlobalVariable.h"
+#include "llvm/IR/InstIterator.h"
+#include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/Module.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCDwarf.h"
 #include "llvm/MC/MCSection.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/MC/MCSymbol.h"
 #include "llvm/MC/MCTargetOptions.h"
if (auto *SkelCU = CU.getSkeleton()) {
           .constructAbstractSubprogramScopeDIE(Scope);
       if (CU.getCUNode()->getSplitDebugInlining())
         SkelCU->constructAbstractSubprogramScopeDIE(Scope);
     } else
       CU.constructAbstractSubprogramScopeDIE(Scope);
   }
 }
 
+void DwarfDebug::constructCallSiteEntryDIEs(const DISubprogram &SP,
+                                            DwarfCompileUnit &CU, DIE &ScopeDIE,
+                                            const MachineFunction &MF) {
+  // Add a call site-related attribute (DWARF5, Sec. 3.3.1.3). Do this only if
+  // the subprogram is required to have one.
+  if (!SP.areAllCallsDescribed() || !SP.isDefinition())
+    return;
+
+  const TargetInstrInfo *TII = MF.getSubtarget().getInstrInfo();
+  assert(TII && "TargetInstrInfo not found: cannot label tail calls");
+
+  // Use DW_AT_call_all_calls to express that call site entries are present
+  // for both tail and non-tail calls. Don't use DW_AT_call_all_source_calls
+  // because one of its requirements is not met: call site entries for
+  // optimized-out calls are elided.
+  CU.addFlag(ScopeDIE, dwarf::DW_AT_call_all_calls);
+
+  // Emit call site entries for each call or tail call in the function.
+  for (const MachineBasicBlock &MBB : MF) {
+    for (const MachineInstr &MI : MBB.instrs()) {
+      // Skip instructions which aren't calls. Both calls and tail-calling jump
+      // instructions (e.g TAILJMPd64) are classified correctly here.
+      if (!MI.isCall())
+        continue;
+
+      // TODO: Add support for targets with delay slots (see: beginInstruction).
+      if (MI.hasDelaySlot())
+        return;
+
+      // If this is a direct call, find the callee's subprogram.
+      const MachineOperand &CalleeOp = MI.getOperand(0);
+      if (!CalleeOp.isGlobal())
+        continue;
+      const Function *CalleeDecl = dyn_cast<Function>(CalleeOp.getGlobal());
+      if (!CalleeDecl || !CalleeDecl->getSubprogram())
+        continue;
+
+      // TODO: Omit call site entries for runtime calls (objc_msgSend, etc).
+      // TODO: Add support for indirect calls.
+
+      bool IsTail = TII->isTailCall(MI);
+
+      // For tail calls, no return PC information is needed. For regular calls,
+      // the return PC is needed to disambiguate paths in the call graph which
+      // could lead to some target function.
+      const MCSymbol *ReturnPC = nullptr;
+      if (!IsTail)
+        ReturnPC = getLabelAfterInsn(&MI);
+
+      assert((IsTail || ReturnPC) && "Call without return PC information");
+      LLVM_DEBUG(dbgs() << "CallSiteEntry: " << MF.getName() << " -> "
+                        << CalleeDecl->getName() << (IsTail ? " [tail]" : "")
+                        << "\n");
+      CU.constructCallSiteEntryDIE(ScopeDIE, *CalleeDecl->getSubprogram(),
+                                   IsTail, ReturnPC);
+    }
+  }
+}
+
 void DwarfDebug::addGnuPubAttributes(DwarfCompileUnit &U, DIE &D) const {
   if (!U.hasDwarfPubSections())
     return;
 
   U.addFlag(D, dwarf::DW_AT_GNU_pubnames);
 }
 
 // Create new DwarfCompileUnit for the given metadata node with tag
void DwarfDebug::beginInstruction(const MachineInstr *MI) {
   if (MI->isMetaInstruction() || MI->getFlag(MachineInstr::FrameSetup))
     return;
   const DebugLoc &DL = MI->getDebugLoc();
   // When we emit a line-0 record, we don't update PrevInstLoc; so look at
   // the last line number actually emitted, to see if it was line 0.
   unsigned LastAsmLine =
       Asm->OutStreamer->getContext().getCurrentDwarfLoc().getLine();
 
+  // Request a label after the call in order to emit AT_return_pc information
+  // in call site entries. TODO: Add support for targets with delay slots.
+  if (SP->areAllCallsDescribed())
+    if (MI->isCall() && !MI->hasDelaySlot())
+      requestLabelAfterInsn(MI);
+
   if (DL == PrevInstLoc) {
     // If we have an ongoing unspecified location, nothing to do here.
     if (!DL)
       return;
     // We have an explicit location, same as the previous location.
     // But we might be coming back to it after a line 0 record.
     if (LastAsmLine == 0 && DL.getLine() != 0) {
       // Reinstate the source location but not marked as a statement.
for (const DINode *DN : SP->getRetainedNodes()) {
         assert(LScopes.getAbstractScopesList().size() == NumAbstractScopes
                && "ensureAbstractVariableIsCreated inserted abstract scopes");
       }
     }
     constructAbstractSubprogramScopeDIE(TheCU, AScope);
   }
 
   ProcessedSPNodes.insert(SP);
-  TheCU.constructSubprogramScopeDIE(SP, FnScope);
+  DIE &ScopeDIE = TheCU.constructSubprogramScopeDIE(SP, FnScope);
   if (auto *SkelCU = TheCU.getSkeleton())
     if (!LScopes.getAbstractScopesList().empty() &&
         TheCU.getCUNode()->getSplitDebugInlining())
       SkelCU->constructSubprogramScopeDIE(SP, FnScope);
 
+  // Construct call site entries.
+  constructCallSiteEntryDIEs(*SP, TheCU, ScopeDIE, *MF);
+
   // Clear debug info
   // Ownership of DbgVariables is a bit subtle - ScopeVariables owns all the
   // DbgVariables except those that are also in AbstractVariables (since they
   // can be used cross-function)
   InfoHolder.getScopeVariables().clear();
   PrevLabel = nullptr;
   CurFn = nullptr;
 }

llvm/lib/DebugInfo/DWARF/DWARFVerifier.cpp

unsigned DWARFVerifier::verifyUnitContents(DWARFUnit &Unit, uint8_t UnitType) {
   for (unsigned I = 0; I < NumDies; ++I) {
     auto Die = Unit.getDIEAtIndex(I);
     if (Die.getTag() == DW_TAG_null)
       continue;
     for (auto AttrValue : Die.attributes()) {
       NumUnitErrors += verifyDebugInfoAttribute(Die, AttrValue);
       NumUnitErrors += verifyDebugInfoForm(Die, AttrValue);
     }
+    if (!verifyDebugInfoCallSite(Die))
+      NumUnitErrors++;
   }
 
   DWARFDie Die = Unit.getUnitDIE(/* ExtractUnitDIEOnly = */ false);
   if (!Die) {
     error() << "Compilation unit without DIE.\n";
     NumUnitErrors++;
     return NumUnitErrors;
   }
unsigned DWARFVerifier::verifyUnitContents(DWARFUnit &Unit, uint8_t UnitType) {
   }
 
   DieRangeInfo RI;
   NumUnitErrors += verifyDieRanges(Die, RI);
 
   return NumUnitErrors;
 }
 
+bool DWARFVerifier::verifyDebugInfoCallSite(const DWARFDie &Die) {
+  if (Die.getTag() != DW_TAG_call_site)
+    return true;
+
+  DWARFDie Curr = Die.getParent();
+  for (; Curr.isValid() && !Curr.isSubprogramDIE(); Curr = Die.getParent()) {
+    if (Curr.isSubroutineDIE()) {
+      error() << "Call site entry nested within inlined subroutine:";
+      Curr.dump(OS);
+      return false;
+    }
+  }
+
+  if (!Curr.isValid()) {
+    error() << "Call site entry not nested within a valid subprogram:";
+    Die.dump(OS);
+    return false;
+  }
+
+  Optional<DWARFFormValue> CallAttr =
+      Curr.find({DW_AT_call_all_calls, DW_AT_call_all_source_calls,
+                 DW_AT_call_all_tail_calls});
+  if (!CallAttr) {
+    error() << "Subprogram with call site entry has no DW_AT_call attribute:";
+    Curr.dump(OS);
+    Die.dump(OS, /*indent*/ 1);
+    return false;
+  }
+
+  return true;
+}
+
 unsigned DWARFVerifier::verifyAbbrevSection(const DWARFDebugAbbrev *Abbrev) {
   unsigned NumErrors = 0;
   if (Abbrev) {
     const DWARFAbbreviationDeclarationSet *AbbrDecls =
         Abbrev->getAbbreviationDeclarationSet(0);
     for (auto AbbrDecl : *AbbrDecls) {
       SmallDenseSet<uint16_t> AttributeSet;
       for (auto Attribute : AbbrDecl.attributes()) {

llvm/lib/IR/Verifier.cpp

void Verifier::visitDISubprogram(const DISubprogram &N) {
 
   if (auto *RawThrownTypes = N.getRawThrownTypes()) {
     auto *ThrownTypes = dyn_cast<MDTuple>(RawThrownTypes);
     AssertDI(ThrownTypes, "invalid thrown types list", &N, RawThrownTypes);
     for (Metadata *Op : ThrownTypes->operands())
       AssertDI(Op && isa<DIType>(Op), "invalid thrown type", &N, ThrownTypes,
                Op);
   }
+
+  if (N.areAllCallsDescribed())
+    AssertDI(N.isDefinition(),
+             "DIFlagAllCallsDescribed must be attached to a definition");
 }
 
 void Verifier::visitDILexicalBlockBase(const DILexicalBlockBase &N) {
   AssertDI(N.getTag() == dwarf::DW_TAG_lexical_block, "invalid tag", &N);
   AssertDI(N.getRawScope() && isa<DILocalScope>(N.getRawScope()),
            "invalid local scope", &N, N.getRawScope());
   if (auto *SP = dyn_cast<DISubprogram>(N.getRawScope()))
     AssertDI(SP->isDefinition(), "scope points into the type hierarchy", &N);

llvm/test/DebugInfo/Generic/callsite-attr-invalid.ll

+; RUN: opt -verify < %s 2>&1 | FileCheck %s
+
+; CHECK: DIFlagAllCallsDescribed must be attached to a definition
+; CHECK: warning: ignoring invalid debug info
+
+; Source:
+;   struct A { ~A(); };
+;   void foo() { A x; }
+
+%struct.A = type { i8 }
+
+define void @_Z3foov() !dbg !8 {
+entry:
+  %x = alloca %struct.A, align 1
+  call void @llvm.dbg.declare(metadata %struct.A* %x, metadata !12, metadata !DIExpression()), !dbg !19
+  call void @_ZN1AD1Ev(%struct.A* %x) #3, !dbg !20
+  ret void, !dbg !20
+}
+
+declare void @llvm.dbg.declare(metadata, metadata, metadata)
+
+declare void @_ZN1AD1Ev(%struct.A*)
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!3, !4, !5, !6}
+!llvm.ident = !{!7}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !1, producer: "clang version 8.0.0 ", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !2)
+!1 = !DIFile(filename: "-", directory: "/Users/vsk/src/builds/llvm-project-tailcall-RA")
+!2 = !{}
+!3 = !{i32 2, !"Dwarf Version", i32 4}
+!4 = !{i32 2, !"Debug Info Version", i32 3}
+!5 = !{i32 1, !"wchar_size", i32 4}
+!6 = !{i32 7, !"PIC Level", i32 2}
+!7 = !{!"clang version 8.0.0 "}
+!8 = distinct !DISubprogram(name: "foo", linkageName: "_Z3foov", scope: !9, file: !9, line: 1, type: !10, isLocal: false, isDefinition: true, scopeLine: 1, flags: DIFlagPrototyped, isOptimized: false, unit: !0, retainedNodes: !2)
+!9 = !DIFile(filename: "<stdin>", directory: "/Users/vsk/src/builds/llvm-project-tailcall-RA")
+!10 = !DISubroutineType(types: !11)
+!11 = !{null}
+!12 = !DILocalVariable(name: "x", scope: !8, file: !9, line: 1, type: !13)
+!13 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "A", file: !9, line: 1, size: 8, flags: DIFlagTypePassByReference, elements: !14, identifier: "_ZTS1A")
+!14 = !{!15}
+!15 = !DISubprogram(name: "~A", scope: !13, file: !9, line: 1, type: !16, isLocal: false, isDefinition: false, scopeLine: 1, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, isOptimized: false)
+!16 = !DISubroutineType(types: !17)
+!17 = !{null, !18}
+!18 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !13, size: 64, flags: DIFlagArtificial | DIFlagObjectPointer)
+!19 = !DILocation(line: 1, column: 36, scope: !8)
+!20 = !DILocation(line: 1, column: 39, scope: !8)

llvm/test/DebugInfo/X86/dwarf-callsite-related-attrs.ll

+; $ clang++ -S -emit-llvm -o - -gdwarf-5 -o - -O1 tail2.cc
+; volatile int sink;
+; void __attribute__((noinline)) bat() { sink++; }
+; void __attribute__((noinline)) bar() { sink++; }
+; void __attribute__((noinline)) foo() {
+;   bar(); bat();
+;   bar(); bat();
+; }
+; int __attribute__((disable_tail_calls)) main() { foo(); }
+
+; REQUIRES: object-emission
+; RUN: %llc_dwarf < %s -o - | FileCheck %s -check-prefix=ASM
+; RUN: %llc_dwarf < %s -filetype=obj -o %t.o
+; RUN: llvm-dwarfdump %t.o -o - | FileCheck %s -check-prefix=OBJ -implicit-check-not=DW_TAG_call_site
+; RUN: llvm-dwarfdump -verify %t.o 2>&1 | FileCheck %s -check-prefix=VERIFY
+; RUN: llvm-dwarfdump -statistics %t.o | FileCheck %s -check-prefix=STATS
+; RUN: llvm-as < %s | llvm-dis | llvm-as | llvm-dis -o /dev/null
+
+; VERIFY: No errors.
+; STATS: "call site entries":5
+
+@sink = global i32 0, align 4, !dbg !0
+
+; ASM: DW_TAG_subprogram
+; ASM:   DW_AT_call_all_calls
+; OBJ: [[bat_sp:.*]]: DW_TAG_subprogram
+; OBJ:   DW_AT_call_all_calls (true)
+; OBJ:   DW_AT_name ("bat")
+define void @_Z3batv() !dbg !13 {
+entry:
+  %0 = load volatile i32, i32* @sink, align 4, !dbg !16, !tbaa !17
+  %inc = add nsw i32 %0, 1, !dbg !16
+  store volatile i32 %inc, i32* @sink, align 4, !dbg !16, !tbaa !17
+  ret void, !dbg !21
+}
+
+; ASM: DW_TAG_subprogram
+; ASM:   DW_AT_call_all_calls
+; OBJ: [[bar_sp:.*]]: DW_TAG_subprogram
+; OBJ:   DW_AT_call_all_calls (true)
+; OBJ:   DW_AT_name ("bar")
+define void @_Z3barv() !dbg !22 {
+entry:
+  %0 = load volatile i32, i32* @sink, align 4, !dbg !23, !tbaa !17
+  %inc = add nsw i32 %0, 1, !dbg !23
+  store volatile i32 %inc, i32* @sink, align 4, !dbg !23, !tbaa !17
+  ret void, !dbg !24
+}
+
+; ASM: DW_TAG_subprogram
+; ASM:   DW_AT_call_all_calls
+; OBJ: [[foo_sp:.*]]: DW_TAG_subprogram
+; OBJ:   DW_AT_call_all_calls (true)
+; OBJ:   DW_AT_name ("foo")
+; OBJ:   DW_TAG_call_site
+; OBJ:     DW_AT_call_origin ([[bar_sp]])
+; OBJ:     DW_AT_call_return_pc ({{[0x]+}}26)
+; OBJ:   DW_TAG_call_site
+; OBJ:     DW_AT_call_origin ([[bat_sp]])
+; OBJ:     DW_AT_call_return_pc ({{[0x]+}}2b)
+; OBJ:   DW_TAG_call_site
+; OBJ:     DW_AT_call_origin ([[bar_sp]])
+; OBJ:     DW_AT_call_return_pc ({{[0x]+}}30)
+; OBJ:   DW_TAG_call_site
+; OBJ:     DW_AT_call_origin ([[bat_sp]])
+; OBJ:     DW_AT_call_tail_call
+define void @_Z3foov() !dbg !25 {
+entry:
+  tail call void @_Z3barv(), !dbg !26
+  tail call void @_Z3batv(), !dbg !27
+  tail call void @_Z3barv(), !dbg !26
+  tail call void @_Z3batv(), !dbg !27
+  ret void, !dbg !28
+}
+
+; ASM: DW_TAG_subprogram
+; ASM: DW_AT_call_all_calls
+; OBJ: DW_TAG_subprogram
+; OBJ: DW_AT_call_all_calls (true)
+; OBJ: DW_AT_name ("main")
+; OBJ:   DW_TAG_call_site
+; OBJ:     DW_AT_call_origin ([[foo_sp]])
+; OBJ:     DW_AT_call_return_pc ({{[0x]+}}46)
+define i32 @main() !dbg !29 {
+entry:
+  call void @_Z3foov(), !dbg !32
+
+  %indirect_target = load void ()*, void ()** undef
+  call void %indirect_target()
+
+  call void asm sideeffect "", "~{dirflag},~{fpsr},~{flags}"()
+
+  ret i32 0, !dbg !33
+}
+
+!llvm.dbg.cu = !{!2}
+!llvm.module.flags = !{!8, !9, !10, !11}
+!llvm.ident = !{!12}
+
+!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+!1 = distinct !DIGlobalVariable(name: "sink", scope: !2, file: !3, line: 1, type: !6, isLocal: false, isDefinition: true)
+!2 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !3, producer: "clang version 7.0.0 ", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !5)
+!3 = !DIFile(filename: "/Users/vsk/src/llvm.org-tailcall/tail2.cc", directory: "/Users/vsk/src/builds/llvm-project-tailcall-RA", checksumkind: CSK_MD5, checksum: "3b61952c21b7f657ddb7c0ad44cf5529")
+!4 = !{}
+!5 = !{!0}
+!6 = !DIDerivedType(tag: DW_TAG_volatile_type, baseType: !7)
+!7 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!8 = !{i32 2, !"Dwarf Version", i32 5}
+!9 = !{i32 2, !"Debug Info Version", i32 3}
+!10 = !{i32 1, !"wchar_size", i32 4}
+!11 = !{i32 7, !"PIC Level", i32 2}
+!12 = !{!"clang version 7.0.0 "}
+!13 = distinct !DISubprogram(name: "bat", linkageName: "_Z3batv", scope: !3, file: !3, line: 2, type: !14, isLocal: false, isDefinition: true, scopeLine: 2, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, isOptimized: true, unit: !2, retainedNodes: !4)
+!14 = !DISubroutineType(types: !15)
+!15 = !{null}
+!16 = !DILocation(line: 2, column: 44, scope: !13)
+!17 = !{!18, !18, i64 0}
+!18 = !{!"int", !19, i64 0}
+!19 = !{!"omnipotent char", !20, i64 0}
+!20 = !{!"Simple C++ TBAA"}
+!21 = !DILocation(line: 2, column: 48, scope: !13)
+!22 = distinct !DISubprogram(name: "bar", linkageName: "_Z3barv", scope: !3, file: !3, line: 3, type: !14, isLocal: false, isDefinition: true, scopeLine: 3, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, isOptimized: true, unit: !2, retainedNodes: !4)
+!23 = !DILocation(line: 3, column: 44, scope: !22)
+!24 = !DILocation(line: 3, column: 48, scope: !22)
+!25 = distinct !DISubprogram(name: "foo", linkageName: "_Z3foov", scope: !3, file: !3, line: 4, type: !14, isLocal: false, isDefinition: true, scopeLine: 4, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, isOptimized: true, unit: !2, retainedNodes: !4)
+!26 = !DILocation(line: 5, column: 3, scope: !25)
+!27 = !DILocation(line: 6, column: 3, scope: !25)
+!28 = !DILocation(line: 7, column: 1, scope: !25)
+!29 = distinct !DISubprogram(name: "main", scope: !3, file: !3, line: 8, type: !30, isLocal: false, isDefinition: true, scopeLine: 8, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, isOptimized: true, unit: !2, retainedNodes: !4)
+!30 = !DISubroutineType(types: !31)
+!31 = !{!7}
+!32 = !DILocation(line: 8, column: 50, scope: !29)
+!33 = !DILocation(line: 8, column: 57, scope: !29)

llvm/test/DebugInfo/X86/dwarfdump-callsite-invalid-1.s

+# RUN: llvm-mc -triple x86_64-apple-darwin %s -filetype=obj -o %t.o
+# RUN: not llvm-dwarfdump -verify %t.o 2>&1 | FileCheck %s
+
+# CHECK: error: Subprogram with call site entry has no DW_AT_call attribute:
+# CHECK: DW_TAG_subprogram
+# CHECK:   DW_AT_name ("main")
+# CHECK: DW_TAG_call_site
+# CHECK:   DW_AT_call_origin
+# CHECK: Errors detected.
+
+# Source:
+## define void @foo() !dbg !25 {
+##   ret void, !dbg !28
+## }
+##
+## define i32 @main() !dbg !29 {
+##   call void @foo(), !dbg !32
+##   ret i32 0, !dbg !33
+## }
+##
+## !llvm.dbg.cu = !{!2}
+## !llvm.module.flags = !{!8, !9, !10, !11}
+## !llvm.ident = !{!12}
+##
+## !0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+## !1 = distinct !DIGlobalVariable(name: "sink", scope: !2, file: !3, line: 1, type: !6, isLocal: false, isDefinition: true)
+## !2 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !3, producer: "clang version 7.0.0 ", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !5)
+## !3 = !DIFile(filename: "/Users/vsk/src/llvm.org-tailcall/tail2.cc", directory: "/Users/vsk/src/builds/llvm-project-tailcall-RA", checksumkind: CSK_MD5, checksum: "3b61952c21b7f657ddb7c0ad44cf5529")
+## !4 = !{}
+## !5 = !{!0}
+## !6 = !DIDerivedType(tag: DW_TAG_volatile_type, baseType: !7)
+## !7 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+## !8 = !{i32 2, !"Dwarf Version", i32 5}
+## !9 = !{i32 2, !"Debug Info Version", i32 3}
+## !10 = !{i32 1, !"wchar_size", i32 4}
+## !11 = !{i32 7, !"PIC Level", i32 2}
+## !12 = !{!"clang version 7.0.0 "}
+## !13 = distinct !DISubprogram(name: "bat", linkageName: "_Z3batv", scope: !3, file: !3, line: 2, type: !14, isLocal: false, isDefinition: true, scopeLine: 2, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, isOptimized: true, unit: !2, retainedNodes: !4)
+## !14 = !DISubroutineType(types: !15)
+## !15 = !{null}
+## !16 = !DILocation(line: 2, column: 44, scope: !13)
+## !17 = !{!18, !18, i64 0}
+## !18 = !{!"int", !19, i64 0}
+## !19 = !{!"omnipotent char", !20, i64 0}
+## !20 = !{!"Simple C++ TBAA"}
+## !21 = !DILocation(line: 2, column: 48, scope: !13)
+## !22 = distinct !DISubprogram(name: "bar", linkageName: "_Z3barv", scope: !3, file: !3, line: 3, type: !14, isLocal: false, isDefinition: true, scopeLine: 3, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, isOptimized: true, unit: !2, retainedNodes: !4)
+## !23 = !DILocation(line: 3, column: 44, scope: !22)
+## !24 = !DILocation(line: 3, column: 48, scope: !22)
+## !25 = distinct !DISubprogram(name: "foo", linkageName: "_Z3foov", scope: !3, file: !3, line: 4, type: !14, isLocal: false, isDefinition: true, scopeLine: 4, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, isOptimized: true, unit: !2, retainedNodes: !4)
+## !26 = !DILocation(line: 5, column: 3, scope: !25)
+## !27 = !DILocation(line: 6, column: 3, scope: !25)
+## !28 = !DILocation(line: 7, column: 1, scope: !25)
+## !29 = distinct !DISubprogram(name: "main", scope: !3, file: !3, line: 8, type: !30, isLocal: false, isDefinition: true, scopeLine: 8, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, isOptimized: true, unit: !2, retainedNodes: !4)
+## !30 = !DISubroutineType(types: !31)
+## !31 = !{!7}
+## !32 = !DILocation(line: 8, column: 50, scope: !29)
+## !33 = !DILocation(line: 8, column: 57, scope: !29)
+
+        .section        __TEXT,__text,regular,pure_instructions
+        .globl  _foo                    ## -- Begin function foo
+_foo:                                   ## @foo
+Lfunc_begin0:
+        .cfi_startproc
+## %bb.0:
+        retq
+Ltmp0:
+Lfunc_end0:
+        .cfi_endproc
+                                        ## -- End function
+        .globl  _main                   ## -- Begin function main
+_main:                                  ## @main
+Lfunc_begin1:
+        .cfi_startproc
+## %bb.0:
+        pushq   %rax
+        .cfi_def_cfa_offset 16
+Ltmp1:
+        callq   _foo
+        xorl    %eax, %eax
+        popq    %rcx
+        retq
+Ltmp2:
+Lfunc_end1:
+        .cfi_endproc
+                                        ## -- End function
+        .section        __DWARF,__debug_str_offs,regular,debug
+Lsection_str_off:
+        .long   36
+        .short  5
+        .short  0
+Lstr_offsets_base0:
+        .section        __DWARF,__debug_str,regular,debug
+Linfo_string:
+        .asciz  "clang version 7.0.0 "  ## string offset=0
+        .asciz  "/Users/vsk/src/llvm.org-tailcall/tail2.cc" ## string offset=21
+        .asciz  "/Users/vsk/src/builds/llvm-project-tailcall-RA" ## string offset=63
+        .asciz  "sink"                  ## string offset=110
+        .asciz  "int"                   ## string offset=115
+        .asciz  "foo"                   ## string offset=119
+        .asciz  "_Z3foov"               ## string offset=123
+        .asciz  "main"                  ## string offset=131
+        .section        __DWARF,__debug_str_offs,regular,debug
+        .long   0
+        .long   21
+        .long   63
+        .long   110
+        .long   115
+        .long   119
+        .long   123
+        .long   131
+        .section        __DWARF,__debug_abbrev,regular,debug
+Lsection_abbrev:
+        .byte   1                       ## Abbreviation Code
+        .byte   17                      ## DW_TAG_compile_unit
+        .byte   1                       ## DW_CHILDREN_yes
+        .byte   37                      ## DW_AT_producer
+        .byte   37                      ## DW_FORM_strx1
+        .byte   19                      ## DW_AT_language
+        .byte   5                       ## DW_FORM_data2
+        .byte   3                       ## DW_AT_name
+        .byte   37                      ## DW_FORM_strx1
+        .byte   114                     ## DW_AT_str_offsets_base
+        .byte   23                      ## DW_FORM_sec_offset
+        .byte   16                      ## DW_AT_stmt_list
+        .byte   23                      ## DW_FORM_sec_offset
+        .byte   27                      ## DW_AT_comp_dir
+        .byte   37                      ## DW_FORM_strx1
+        .ascii  "\341\177"              ## DW_AT_APPLE_optimized
+        .byte   25                      ## DW_FORM_flag_present
+        .byte   17                      ## DW_AT_low_pc
+        .byte   1                       ## DW_FORM_addr
+        .byte   18                      ## DW_AT_high_pc
+        .byte   6                       ## DW_FORM_data4
+        .byte   0                       ## EOM(1)
+        .byte   0                       ## EOM(2)
+        .byte   2                       ## Abbreviation Code
+        .byte   52                      ## DW_TAG_variable
+        .byte   0                       ## DW_CHILDREN_no
+        .byte   3                       ## DW_AT_name
+        .byte   37                      ## DW_FORM_strx1
+        .byte   73                      ## DW_AT_type
+        .byte   19                      ## DW_FORM_ref4
+        .byte   63                      ## DW_AT_external
+        .byte   25                      ## DW_FORM_flag_present
+        .byte   58                      ## DW_AT_decl_file
+        .byte   11                      ## DW_FORM_data1
+        .byte   59                      ## DW_AT_decl_line
+        .byte   11                      ## DW_FORM_data1
+        .byte   0                       ## EOM(1)
+        .byte   0                       ## EOM(2)
+        .byte   3                       ## Abbreviation Code
+        .byte   53                      ## DW_TAG_volatile_type
+        .byte   0                       ## DW_CHILDREN_no
+        .byte   73                      ## DW_AT_type
+        .byte   19                      ## DW_FORM_ref4
+        .byte   0                       ## EOM(1)
+        .byte   0                       ## EOM(2)
+        .byte   4                       ## Abbreviation Code
+        .byte   36                      ## DW_TAG_base_type
+        .byte   0                       ## DW_CHILDREN_no
+        .byte   3                       ## DW_AT_name
+        .byte   37                      ## DW_FORM_strx1
+        .byte   62                      ## DW_AT_encoding
+        .byte   11                      ## DW_FORM_data1
+        .byte   11                      ## DW_AT_byte_size
+        .byte   11                      ## DW_FORM_data1
+        .byte   0                       ## EOM(1)
+        .byte   0                       ## EOM(2)
+        .byte   5                       ## Abbreviation Code
+        .byte   46                      ## DW_TAG_subprogram
+        .byte   0                       ## DW_CHILDREN_no
+        .byte   17                      ## DW_AT_low_pc
+        .byte   1                       ## DW_FORM_addr
+        .byte   18                      ## DW_AT_high_pc
+        .byte   6                       ## DW_FORM_data4
+        .ascii  "\347\177"              ## DW_AT_APPLE_omit_frame_ptr
+        .byte   25                      ## DW_FORM_flag_present
+        .byte   64                      ## DW_AT_frame_base
+        .byte   24                      ## DW_FORM_exprloc
+##        .byte   122                     ## DW_AT_call_all_calls
+##        .byte   25                      ## DW_FORM_flag_present
+        .byte   110                     ## DW_AT_linkage_name
+        .byte   37                      ## DW_FORM_strx1
+        .byte   3                       ## DW_AT_name
+        .byte   37                      ## DW_FORM_strx1
+        .byte   58                      ## DW_AT_decl_file
+        .byte   11                      ## DW_FORM_data1
+        .byte   59                      ## DW_AT_decl_line
+        .byte   11                      ## DW_FORM_data1
+        .byte   63                      ## DW_AT_external
+        .byte   25                      ## DW_FORM_flag_present
+        .ascii  "\341\177"              ## DW_AT_APPLE_optimized
+        .byte   25                      ## DW_FORM_flag_present
+        .byte   0                       ## EOM(1)
+        .byte   0                       ## EOM(2)
+        .byte   6                       ## Abbreviation Code
+        .byte   46                      ## DW_TAG_subprogram
+        .byte   1                       ## DW_CHILDREN_yes
+        .byte   17                      ## DW_AT_low_pc
+        .byte   1                       ## DW_FORM_addr
+        .byte   18                      ## DW_AT_high_pc
+        .byte   6                       ## DW_FORM_data4
+        .ascii  "\347\177"              ## DW_AT_APPLE_omit_frame_ptr
+        .byte   25                      ## DW_FORM_flag_present
+        .byte   64                      ## DW_AT_frame_base
+        .byte   24                      ## DW_FORM_exprloc
+##        .byte   122                     ## DW_AT_call_all_calls
+##        .byte   25                      ## DW_FORM_flag_present
+        .byte   3                       ## DW_AT_name
+        .byte   37                      ## DW_FORM_strx1
+        .byte   58                      ## DW_AT_decl_file
+        .byte   11                      ## DW_FORM_data1
+        .byte   59                      ## DW_AT_decl_line
+        .byte   11                      ## DW_FORM_data1
+        .byte   73                      ## DW_AT_type
+        .byte   19                      ## DW_FORM_ref4
+        .byte   63                      ## DW_AT_external
+        .byte   25                      ## DW_FORM_flag_present
+        .ascii  "\341\177"              ## DW_AT_APPLE_optimized
+        .byte   25                      ## DW_FORM_flag_present
+        .byte   0                       ## EOM(1)
+        .byte   0                       ## EOM(2)
+        .byte   7                       ## Abbreviation Code
+        .byte   72                      ## DW_TAG_call_site
+        .byte   0                       ## DW_CHILDREN_no
+        .byte   127                     ## DW_AT_call_origin
+        .byte   19                      ## DW_FORM_ref4
+        .byte   0                       ## EOM(1)
+        .byte   0                       ## EOM(2)
+        .byte   0                       ## EOM(3)
+        .section        __DWARF,__debug_info,regular,debug
+Lsection_info:
+Lcu_begin0:
+        .long   99                      ## Length of Unit
+        .short  5                       ## DWARF version number
+        .byte   1                       ## DWARF Unit Type
+        .byte   8                       ## Address Size (in bytes)
+.set Lset0, Lsection_abbrev-Lsection_abbrev ## Offset Into Abbrev. Section
+        .long   Lset0
+        .byte   1                       ## Abbrev [1] 0xc:0x5b DW_TAG_compile_unit
+        .byte   0                       ## DW_AT_producer
+        .short  4                       ## DW_AT_language
+        .byte   1                       ## DW_AT_name
+.set Lset1, Lstr_offsets_base0-Lsection_str_off ## DW_AT_str_offsets_base
+        .long   Lset1
+.set Lset2, Lline_table_start0-Lsection_line ## DW_AT_stmt_list
+        .long   Lset2
+        .byte   2                       ## DW_AT_comp_dir
+                                        ## DW_AT_APPLE_optimized
+        .quad   Lfunc_begin0            ## DW_AT_low_pc
+.set Lset3, Lfunc_end1-Lfunc_begin0     ## DW_AT_high_pc
+        .long   Lset3
+        .byte   2                       ## Abbrev [2] 0x26:0x8 DW_TAG_variable
+        .byte   3                       ## DW_AT_name
+        .long   46                      ## DW_AT_type
+                                        ## DW_AT_external
+        .byte   1                       ## DW_AT_decl_file
+        .byte   1                       ## DW_AT_decl_line
+        .byte   3                       ## Abbrev [3] 0x2e:0x5 DW_TAG_volatile_type
+        .long   51                      ## DW_AT_type
+        .byte   4                       ## Abbrev [4] 0x33:0x4 DW_TAG_base_type
+        .byte   4                       ## DW_AT_name
+        .byte   5                       ## DW_AT_encoding
+        .byte   4                       ## DW_AT_byte_size
+        .byte   5                       ## Abbrev [5] 0x37:0x13 DW_TAG_subprogram
+        .quad   Lfunc_begin0            ## DW_AT_low_pc
+.set Lset4, Lfunc_end0-Lfunc_begin0     ## DW_AT_high_pc
+        .long   Lset4
+                                        ## DW_AT_APPLE_omit_frame_ptr
+        .byte   1                       ## DW_AT_frame_base
+        .byte   87
+                                        ## DW_AT_call_all_calls
+        .byte   6                       ## DW_AT_linkage_name
+        .byte   5                       ## DW_AT_name
+        .byte   1                       ## DW_AT_decl_file
+        .byte   4                       ## DW_AT_decl_line
+                                        ## DW_AT_external
+                                        ## DW_AT_APPLE_optimized
+        .byte   6                       ## Abbrev [6] 0x4a:0x1c DW_TAG_subprogram
+        .quad   Lfunc_begin1            ## DW_AT_low_pc
+.set Lset5, Lfunc_end1-Lfunc_begin1     ## DW_AT_high_pc
+        .long   Lset5
+                                        ## DW_AT_APPLE_omit_frame_ptr
+        .byte   1                       ## DW_AT_frame_base
+        .byte   87
+                                        ## DW_AT_call_all_calls
+        .byte   7                       ## DW_AT_name
+        .byte   1                       ## DW_AT_decl_file
+        .byte   8                       ## DW_AT_decl_line
+        .long   51                      ## DW_AT_type
+                                        ## DW_AT_external
+                                        ## DW_AT_APPLE_optimized
+        .byte   7                       ## Abbrev [7] 0x60:0x5 DW_TAG_call_site
+        .long   55                      ## DW_AT_call_origin
+        .byte   0                       ## End Of Children Mark
+        .byte   0                       ## End Of Children Mark
+        .section        __DWARF,__debug_macinfo,regular,debug
+Ldebug_macinfo:
+        .byte   0                       ## End Of Macro List Mark
+        .section        __DWARF,__debug_names,regular,debug
+Ldebug_names_begin:
+.set Lset6, Lnames_end0-Lnames_start0   ## Header: unit length
+        .long   Lset6
+Lnames_start0:
+        .short  5                       ## Header: version
+        .short  0                       ## Header: padding
+        .long   1                       ## Header: compilation unit count
+        .long   0                       ## Header: local type unit count
+        .long   0                       ## Header: foreign type unit count
+        .long   4                       ## Header: bucket count
+        .long   4                       ## Header: name count
+.set Lset7, Lnames_abbrev_end0-Lnames_abbrev_start0 ## Header: abbreviation table size
+        .long   Lset7
+        .long   8                       ## Header: augmentation string size
+        .ascii  "LLVM0700"              ## Header: augmentation string
+.set Lset8, Lcu_begin0-Lsection_info    ## Compilation unit 0
+        .long   Lset8
+        .long   1                       ## Bucket 0
+        .long   2                       ## Bucket 1
+        .long   3                       ## Bucket 2
+        .long   4                       ## Bucket 3
+        .long   193495088               ## Hash in Bucket 0
+        .long   193491849               ## Hash in Bucket 1
+        .long   2090499946              ## Hash in Bucket 2
+        .long   -1257882357             ## Hash in Bucket 3
+        .long   115                     ## String in Bucket 0: int
+        .long   119                     ## String in Bucket 1: foo
+        .long   131                     ## String in Bucket 2: main
+        .long   123                     ## String in Bucket 3: _Z3foov
+.set Lset9, Lnames3-Lnames_entries0     ## Offset in Bucket 0
+        .long   Lset9
+.set Lset10, Lnames0-Lnames_entries0    ## Offset in Bucket 1
+        .long   Lset10
+.set Lset11, Lnames1-Lnames_entries0    ## Offset in Bucket 2
+        .long   Lset11
+.set Lset12, Lnames2-Lnames_entries0    ## Offset in Bucket 3
+        .long   Lset12
+Lnames_abbrev_start0:
+        .byte   46                      ## Abbrev code
+        .byte   46                      ## DW_TAG_subprogram
+        .byte   3                       ## DW_IDX_die_offset
+        .byte   19                      ## DW_FORM_ref4
+        .byte   0                       ## End of abbrev
+        .byte   0                       ## End of abbrev
+        .byte   36                      ## Abbrev code
+        .byte   36                      ## DW_TAG_base_type
+        .byte   3                       ## DW_IDX_die_offset
+        .byte   19                      ## DW_FORM_ref4
+        .byte   0                       ## End of abbrev
+        .byte   0                       ## End of abbrev
+        .byte   0                       ## End of abbrev list
+Lnames_abbrev_end0:
+Lnames_entries0:
+Lnames3:
+        .byte   36                      ## Abbreviation code
+        .long   51                      ## DW_IDX_die_offset
+        .long   0                       ## End of list: int
+Lnames0:
+        .byte   46                      ## Abbreviation code
+        .long   55                      ## DW_IDX_die_offset
+        .long   0                       ## End of list: foo
+Lnames1:
+        .byte   46                      ## Abbreviation code
+        .long   74                      ## DW_IDX_die_offset
+        .long   0                       ## End of list: main
+Lnames2:
+        .byte   46                      ## Abbreviation code
+        .long   55                      ## DW_IDX_die_offset
+        .long   0                       ## End of list: _Z3foov
+Lnames_end0:
+
+.subsections_via_symbols
+        .section        __DWARF,__debug_line,regular,debug
+Lsection_line:
+Lline_table_start0:

llvm/tools/llvm-dwarfdump/Statistics.cpp

 
 /// Holds accumulated global statistics about local variables.
 struct GlobalStats {
   /// Total number of PC range bytes covered by DW_AT_locations.
   unsigned ScopeBytesCovered = 0;
   /// Total number of PC range bytes in each variable's enclosing scope,
   /// starting from the first definition of the variable.
   unsigned ScopeBytesFromFirstDefinition = 0;
+  /// Total number of call site entries (DW_TAG_call_site).
+  unsigned CallSiteEntries = 0;
 };
 
 /// Extract the low pc from a Die.
 static uint64_t getLowPC(DWARFDie Die) {
   auto RangesOrError = Die.getAddressRanges();
   DWARFAddressRangesVector Ranges;
   if (RangesOrError)
     Ranges = RangesOrError.get();
if (HasLoc) {
           }
         }
         assert(BytesInScope);
       } else {
         // Assume the entire range is covered by a single location.
         BytesCovered = BytesInScope;
       }
     }
+  } else if (Die.getTag() == dwarf::DW_TAG_call_site) {
+    GlobalStats.CallSiteEntries++;
+    return;
   } else {
-    // Not a variable or constant member.
+    // Not a variable, constant member, or call site.
     return;
   }
 
   // Collect PC range coverage data.
   auto &FnStats = FnStatMap[Prefix];
   if (DWARFDie D =
           Die.getAttributeValueAsReferencedDie(dwarf::DW_AT_abstract_origin))
     Die = D;
LLVM_DEBUG(llvm::dbgs() << "Variable location quality metrics\n";
              llvm::dbgs() << "---------------------------------\n");
   printDatum(OS, "file", Filename.str());
   printDatum(OS, "format", FormatName);
   printDatum(OS, "source functions", NumFunctions);
   printDatum(OS, "inlined functions", NumInlinedFunctions);
   printDatum(OS, "unique source variables", VarUnique);
   printDatum(OS, "source variables", VarTotal);
   printDatum(OS, "variables with location", VarWithLoc);
+  printDatum(OS, "call site entries", GlobalStats.CallSiteEntries);
   printDatum(OS, "scope bytes total",
              GlobalStats.ScopeBytesFromFirstDefinition);
   printDatum(OS, "scope bytes covered", GlobalStats.ScopeBytesCovered);
   OS << "}\n";
   LLVM_DEBUG(
       llvm::dbgs() << "Total Availability: "
                    << (int)std::round((VarWithLoc * 100.0) / VarTotal) << "%\n";
       llvm::dbgs() << "PC Ranges covered: "
                    << (int)std::round((GlobalStats.ScopeBytesCovered * 100.0) /
                                       GlobalStats.ScopeBytesFromFirstDefinition)
                    << "%\n");
   return true;
 }