[Coverage] Allow Clang coverage to be used with debug info correlation.

[zequanwu]

Summary

Debug info correlation is an option in InstrProfiling pass, which is used by
both IR instrumentation and front-end instrumentation. So, Clang coverage can
also benefits the binary size saving from it.

[zequanwu]

Update.
Binary may still contains __llvm_prf_names sections for functions that are not emitted.

[zequanwu]

Rebase and correct name section size in profile header.

[ellis]

Thanks for working on this! I've added a few other reviewers that might be interested. In particular it might conflict with the stack D138846 IIRC
It seems that the __llvm_prf_names is retained in this mode. What is the overhead of this section generally? Can we instead use debug info to lookup function names?

[zequanwu]

It seems that the __llvm_prf_names is retained in this mode. What is the overhead of this section generally? Can we instead use debug info to lookup function names?

With debug info correlation enabled, __llvm_prf_names section will only contain functions names that are not emitted to the final binary, not even in debug info. So, this section is still much smaller compared to when not enabling debug info correlation. This is used to indicate that those functions are covered but not executed.

Example from the test case above:

$ cat a.cpp
struct A {
  void unused_func() {}
};
void used_func() {}
int main() {
  used_func();
  return 0;
}
$ clang -fprofile-instr-generate -fcoverage-mapping -mllvm -enable-name-compression=false -mllvm -debug-info-correlate -g a.cpp -o a.out
$ llvm-objdump --section=__llvm_prf_names --full-contents a.out

a.out:  file format elf64-x86-64
Contents of section __llvm_prf_names:
 7b65 14005f5a 4e314131 31756e75 7365645f  .._ZN1A11unused_
 7b75 66756e63 4576                        funcEv

[ellis]

In D157913#4626007, @zequanwu wrote:

It seems that the __llvm_prf_names is retained in this mode. What is the overhead of this section generally? Can we instead use debug info to lookup function names?

With debug info correlation enabled, __llvm_prf_names section will only contain functions names that are not emitted to the final binary, not even in debug info. So, this section is still much smaller compared to when not enabling debug info correlation. This is used to indicate that those functions are covered but not executed.

Example from the test case above:

$ cat a.cpp
struct A {
  void unused_func() {}
};
void used_func() {}
int main() {
  used_func();
  return 0;
}
$ clang -fprofile-instr-generate -fcoverage-mapping -mllvm -enable-name-compression=false -mllvm -debug-info-correlate -g a.cpp -o a.out
$ llvm-objdump --section=__llvm_prf_names --full-contents a.out

a.out:  file format elf64-x86-64
Contents of section __llvm_prf_names:
 7b65 14005f5a 4e314131 31756e75 7365645f  .._ZN1A11unused_
 7b75 66756e63 4576                        funcEv

Thanks for the explanation!

clang/test/CodeGen/coverage-debug-info-correlate.c

1 ↗

(On Diff #554048)

I think this test can be generalized to check that __llvm_profile_raw_version is emitted with or without debug info correlation.

compiler-rt/test/profile/Darwin/coverage-debug-info-correlate.cpp

10

NIT

30

Is it worth testing that %t.normal.profdata emits the same coverage?

llvm/lib/ProfileData/Coverage/CoverageMappingReader.cpp

1074–1089

I don't quite understand why this was changed. Is there is a test case that covers this?

[zequanwu]

Address comments.

[zequanwu]

compiler-rt/test/profile/Darwin/coverage-debug-info-correlate.cpp

30

Added testing for %t.normal.profdata.

llvm/lib/ProfileData/Coverage/CoverageMappingReader.cpp

1074–1089

This part of code is used by llvm-cov. Originally, it always checks if the instrumented binary contains the __llvm_prf_names section and assumes all instrumented function names are store there. Now, it will firstly create InstrProfSymtab from the indexed profile file and add remaining function names to this InstrProfSymtab from __llvm_prf_names section in the instrumented binary, if there is one.

This is covered by // RUN: llvm-cov export --format=lcov --instr-profile=%t.profdata %t | FileCheck %s -check-prefix=NAME, where _Z9used_funcv and main are stored in debug info and later moved to indexed profile file, and _ZN1A11unused_funcEv is stored in __llvm_prf_names section in the binary.

[phosek]

In D157913#4626007, @zequanwu wrote:

It seems that the __llvm_prf_names is retained in this mode. What is the overhead of this section generally? Can we instead use debug info to lookup function names?

With debug info correlation enabled, __llvm_prf_names section will only contain functions names that are not emitted to the final binary, not even in debug info.

Could we emit those names into the .debug_str section?

[zequanwu]

In D157913#4638569, @phosek wrote:

In D157913#4626007, @zequanwu wrote:

It seems that the __llvm_prf_names is retained in this mode. What is the overhead of this section generally? Can we instead use debug info to lookup function names?

With debug info correlation enabled, __llvm_prf_names section will only contain functions names that are not emitted to the final binary, not even in debug info.

Could we emit those names into the .debug_str section?

Yes, I think it's feasible by creating a fake variable debug info that contains all the skipped function names in the source file for each object file, but that's a bit more overhead in debug info compared to just plain __llvm_prf_names in binary, which is only about 0.2% or less of original size [1].

[1]: https://bugs.chromium.org/p/chromium/issues/detail?id=1463755#c8

[ellis]

In D157913#4638845, @zequanwu wrote:

In D157913#4638569, @phosek wrote:

In D157913#4626007, @zequanwu wrote:

It seems that the __llvm_prf_names is retained in this mode. What is the overhead of this section generally? Can we instead use debug info to lookup function names?

With debug info correlation enabled, __llvm_prf_names section will only contain functions names that are not emitted to the final binary, not even in debug info.

Could we emit those names into the .debug_str section?

Yes, I think it's feasible by creating a fake variable debug info that contains all the skipped function names in the source file for each object file, but that's a bit more overhead in debug info compared to just plain __llvm_prf_names in binary, which is only about 0.2% or less of original size [1].

[1]: https://bugs.chromium.org/p/chromium/issues/detail?id=1463755#c8

Since the .debug_str section can be stripped before execution time, I don't count that towards the binary size overhead. But I believe the __llvm_prf_names section cannot be stripped as is. So it would be an improvement if we could completely remove the __llvm_prf_names section and emit names in the .debug_str section.

I see that you have one case where the overhead of the names section is just 0.2%. I wonder if this is common or if there exist real-world scenarios where the overhead is more significant. If not then leaving the names section in the binary might be ok, but we should probably leave a note explaining how we could remove it if we emit the names in debug info.

[zequanwu]

Remove profile name section.

Unused coverage function names are stored in debug info as a fake global variable info:

0x0000000b: DW_TAG_compile_unit
...
0x00000071:   DW_TAG_variable
                DW_AT_name      ("__llvm_coverage_names")
                DW_AT_type      (0x00000097 "Coverage Type")
                DW_AT_location  (DW_OP_addr 0x0)

0x00000084:     DW_TAG_LLVM_annotation
                  DW_AT_name    ("Cov Function Name")
                  DW_AT_const_value     ("bar")

0x0000008d:     DW_TAG_LLVM_annotation
                  DW_AT_name    ("Cov Function Name")
                  DW_AT_const_value     ("baz")

llvm-cov will need to retrieve those names from the binary's debug info.

The reasons for not writing those names into the indexed profile file are following:

1. llvm-cov always need to read llvm_covfun and llvm_covmap from the unstripped binary, so it doesn't matter if those names are read from the binary or the indexed profile.
2. Since those names are just an array of strings, they don't have counter/data info. When llvm-profdata writes indexed profile, it iterates profile data to write records, so those unreferenced names are skipped even if I append them to the end of profile symtab. I'm not sure how we can simply append those names into the end of function name strings at indexed profile.

Overall, there are basically two types of function names:

1. Instrumented function names, which are stored in dwarf and later copied to indexed profile. llvm-cov reads them from indexed profile.
2. Unused function names(could be empty), which are stored in dwarf. llvm-cov reads them from the debug info.

[ellis]

It looks like debug-info-correlate-coverage.ll was renamed twice. Is this intended?

compiler-rt/lib/profile/InstrProfilingWriter.c

276–277 ↗

(On Diff #556805)

Can we remove changes to this file now that we are stripping the names section?

llvm/lib/ProfileData/InstrProfCorrelator.cpp

423

I think this return should be on the line above to break out of the for loop early. Or did I miscount the brackets?

llvm/lib/ProfileData/InstrProfReader.cpp

577–578 ↗

(On Diff #556805)

I think these changes can also be removed

llvm/lib/Transforms/Instrumentation/InstrProfiling.cpp

769

Just so that I understand. Does this code run only for names of unused functions? Or will we store all function names with CovFunctionNameAnnotation?

[zequanwu]

Address comments.

[zequanwu]

In D157913#4646184, @ellis wrote:

It looks like debug-info-correlate-coverage.ll was renamed twice. Is this intended?

I just moved llvm/test/Instrumentation/InstrProfiling/debug-info-correlate-coverage.ll. to llvm/test/Instrumentation/InstrProfiling/debug-info-correlate-byte-coverage.ll and created a new test file llvm/test/Instrumentation/InstrProfiling/debug-info-correlate-clang-coverage.ll.

compiler-rt/lib/profile/InstrProfilingWriter.c

276–277 ↗

(On Diff #556805)

Reverted all changes in this file.

llvm/lib/ProfileData/InstrProfCorrelator.cpp

423

Removed that if. It's already checked inside IsDIEOfCovName.

llvm/lib/Transforms/Instrumentation/InstrProfiling.cpp

769

Just the names of unused functions. All instrumented functions names will still be stored at the same place as before.

[ellis]

In D157913#4646201, @zequanwu wrote:

In D157913#4646184, @ellis wrote:

It looks like debug-info-correlate-coverage.ll was renamed twice. Is this intended?

I just moved llvm/test/Instrumentation/InstrProfiling/debug-info-correlate-coverage.ll. to llvm/test/Instrumentation/InstrProfiling/debug-info-correlate-byte-coverage.ll and created a new test file llvm/test/Instrumentation/InstrProfiling/debug-info-correlate-clang-coverage.ll.

Got it! Sorry I got confused by the UI.

Sounds good to me! I'm excited to see clang instrumentation can take full advantage of debug info correlation!

[thakis]

Looks like this breaks check-clang on mac: http://45.33.8.238/macm1/69297/step_7.txt

Please take a look and revert for now if it takes a while to fix.

[zequanwu]

In D157913#4646718, @thakis wrote:

Looks like this breaks check-clang on mac: http://45.33.8.238/macm1/69297/step_7.txt

Please take a look and revert for now if it takes a while to fix.

https://github.com/llvm/llvm-project/commit/1f33bfc23fb9e94b4db75b1b18fd00a438446f51 should fix it.

[phosek]

llvm/lib/ProfileData/InstrProfCorrelator.cpp

42

I missed this earlier, but I think that spelling this out in full, that is Coverage Function Name, would be more consistent with the Coverage Type.

[zequanwu]

llvm/lib/ProfileData/InstrProfCorrelator.cpp

42

Renamed at: https://github.com/llvm/llvm-project/commit/37402c34918a4627de77c3b20964207892383242

[zequanwu]

For some unknown reasons, linker still generates __llvm_prf_names section in the final binary on mac even if the object file doesn't have this section. And I cannot use llvm-objdump to get anything from that section.

$ llvm-readelf -S ../tmp/a.out
...
  Section {
    Index: 15
    Name: __llvm_prf_names (5F 5F 6C 6C 76 6D 5F 70 72 66 5F 6E 61 6D 65 73)
    Segment: __DATA (5F 5F 44 41 54 41 00 00 00 00 00 00 00 00 00 00)
    Address: 0x100018000
    Size: 0x0
    Offset: 98304
    Alignment: 0
    RelocationOffset: 0x0
    RelocationCount: 0
    Type: Regular (0x0)
    Attributes [ (0x0)
    ]
    Reserved1: 0x0
    Reserved2: 0x0
    Reserved3: 0x0
  }
...
$ llvm-objdump --section=__llvm_prf_names --full-contents ../tmp/a.out
../tmp/a.out:	file format mach-o arm64

I will delete the test for now as it's not working on mac: compiler-rt/test/profile/Darwin/coverage-debug-info-correlate.cpp

[ellis]

In D157913#4648296, @zequanwu wrote:

For some unknown reasons, linker still generates __llvm_prf_names section in the final binary on mac even if the object file doesn't have this section. And I cannot use llvm-objdump to get anything from that section.

$ llvm-readelf -S ../tmp/a.out
...
  Section {
    Index: 15
    Name: __llvm_prf_names (5F 5F 6C 6C 76 6D 5F 70 72 66 5F 6E 61 6D 65 73)
    Segment: __DATA (5F 5F 44 41 54 41 00 00 00 00 00 00 00 00 00 00)
    Address: 0x100018000
    Size: 0x0
    Offset: 98304
    Alignment: 0
    RelocationOffset: 0x0
    RelocationCount: 0
    Type: Regular (0x0)
    Attributes [ (0x0)
    ]
    Reserved1: 0x0
    Reserved2: 0x0
    Reserved3: 0x0
  }
...
$ llvm-objdump --section=__llvm_prf_names --full-contents ../tmp/a.out
../tmp/a.out:	file format mach-o arm64

I will delete the test for now as it's not working on mac: compiler-rt/test/profile/Darwin/coverage-debug-info-correlate.cpp

I have seen that MachO sections remain in the header even if the size is zero which seems to be the case here. You could use llvm-objdump to verify that the section exists but the size is zero.

[zequanwu]

I feel like either this feature not working well with mac or we should keep __llvm_prf_names section in the binary.

Current idea is to completely get rid of __llvm_prf_names section in the binary. Even if I fixed the issue https://reviews.llvm.org/D157913#4648296, llvm-cov will need to read information from 3 different places on mac: the binary (for __llvm_cov_fun and __llvm_cov_map), debug info (unused function names, which could live in __llvm_prf_names) and indexed profile file for (counter, data, instrumented function names). If we keep __llvm_prf_names in the binary, then llvm-cov doesn't need to look into debug info again.

[zequanwu]

In D157913#4648313, @ellis wrote:

I have seen that MachO sections remain in the header even if the size is zero which seems to be the case here. You could use llvm-objdump to verify that the section exists but the size is zero.

Thanks, I didn't notice that. And this can be easily detected.

[phosek]

We've been investigating a serious performance regression in our latest Clang roll that is affecting coverage. Whereas previously, we could process all coverage data in under an hour, now the job times out after 6 hours. After investigation, I found out that this change is the culprit. Specifically, it seems like llvm-cov has gotten significantly slower.

Before this change:

$ time llvm-cov show -instr-profile merged.profdata -summary-only e91b5a1a324aa156
llvm-cov     0.92s user 0.12s system 99% cpu 1.038 total

After this change:

$ time llvm-cov show -instr-profile merged.profdata -summary-only e91b5a1a324aa156
llvm-cov     5.61s user 0.89s system 99% cpu 6.495 total

I did some investigation and it seems like the time increase is related to InstrProfSymtab that used in the CoverageReader. I saw that subsequent changes fix some issues trying to avoid unnecessary copies, but that still hasn't addressed the slowdown since the tip-of-tree is still exhibiting this issue.

It's also possible that there isn't any issue that was introduced here, the problem is that the implementation simply doesn't scale. For example, the binary e91b5a1a324aa156 I used here has 95527 symbol entries, most of them are the __covrec_* symbols, and that's one of the smaller binaries we have in our build.

Regardless, this is still a serious regression and I'm wondering if there's anything we can do short of reverting this change?

clang/lib/CodeGen/CoverageMappingGen.cpp

 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
 #include <optional>
 
 // This selects the coverage mapping format defined when `InstrProfData.inc`
 // is textually included.
 #define COVMAP_V3
 
+namespace llvm {
+extern cl::opt<bool> DebugInfoCorrelate;
+} // namespace llvm
+
 static llvm::cl::opt<bool> EmptyLineCommentCoverage(
     "emptyline-comment-coverage",
     llvm::cl::desc("Emit emptylines and comment lines as skipped regions (only "
                    "disable it on test)"),
     llvm::cl::init(true), llvm::cl::Hidden);
 
 static llvm::cl::opt<bool> SystemHeadersCoverage(
     "system-headers-coverage",
auto NamesArrTy = llvm::ArrayType::get(llvm::Type::getInt8PtrTy(Ctx),
                                            FunctionNames.size());
     auto NamesArrVal = llvm::ConstantArray::get(NamesArrTy, FunctionNames);
     // This variable will *NOT* be emitted to the object file. It is used
     // to pass the list of names referenced to codegen.
     new llvm::GlobalVariable(CGM.getModule(), NamesArrTy, true,
                              llvm::GlobalValue::InternalLinkage, NamesArrVal,
                              llvm::getCoverageUnusedNamesVarName());
   }
+  const StringRef VarName(INSTR_PROF_QUOTE(INSTR_PROF_RAW_VERSION_VAR));
+  llvm::Type *IntTy64 = llvm::Type::getInt64Ty(Ctx);
+  uint64_t ProfileVersion = INSTR_PROF_RAW_VERSION;
+  if (llvm::DebugInfoCorrelate)
+    ProfileVersion |= VARIANT_MASK_DBG_CORRELATE;
+  auto *VersionVariable = new llvm::GlobalVariable(
+      CGM.getModule(), llvm::Type::getInt64Ty(Ctx), true,
+      llvm::GlobalValue::WeakAnyLinkage,
+      llvm::Constant::getIntegerValue(IntTy64, llvm::APInt(64, ProfileVersion)),
+      VarName);
+  VersionVariable->setVisibility(llvm::GlobalValue::HiddenVisibility);
+  llvm::Triple TT(CGM.getModule().getTargetTriple());
+  if (TT.supportsCOMDAT()) {
+    VersionVariable->setLinkage(llvm::GlobalValue::ExternalLinkage);
+    VersionVariable->setComdat(CGM.getModule().getOrInsertComdat(VarName));
+  }
 }
 
 unsigned CoverageMappingModuleGen::getFileID(FileEntryRef File) {
   auto It = FileEntries.find(File);
   if (It != FileEntries.end())
     return It->second;
   unsigned FileID = FileEntries.size() + 1;
   FileEntries.insert(std::make_pair(File, FileID));

clang/test/CodeGen/coverage-profile-raw-version.c

+// RUN: %clang_cc1 -debug-info-kind=standalone -fprofile-instrument=clang -fcoverage-mapping -emit-llvm -o - %s | FileCheck %s
+// RUN: %clang_cc1 -debug-info-kind=standalone -mllvm -debug-info-correlate -fprofile-instrument=clang -fcoverage-mapping -emit-llvm -o - %s | FileCheck %s --check-prefix=DEBUG_INFO
+
+// CHECK: @__llvm_profile_raw_version = hidden constant i64 8, comdat
+// DEBUG_INFO: @__llvm_profile_raw_version = hidden constant i64 576460752303423496, comdat
+
+int main() {
+    return 0;
+}

compiler-rt/test/profile/Darwin/coverage-debug-info-correlate.cpp

+// Test debug info correlate with clang coverage.
+
+// Test the case when there is no __llvm_prf_names in the binary.
+// RUN: %clang_profgen -o %t.normal -fcoverage-mapping %S/../Inputs/instrprof-debug-info-correlate-main.cpp %S/../Inputs/instrprof-debug-info-correlate-foo.cpp
+// RUN: env LLVM_PROFILE_FILE=%t.profraw %run %t.normal
+// RUN: llvm-profdata merge -o %t.normal.profdata %t.profraw
+
+// RUN: %clang_profgen -o %t -g -mllvm --debug-info-correlate -fcoverage-mapping %S/../Inputs/instrprof-debug-info-correlate-main.cpp %S/../Inputs/instrprof-debug-info-correlate-foo.cpp
+// RUN: env LLVM_PROFILE_FILE=%t.proflite %run %t
+// RUN: llvm-profdata merge -o %t.profdata --debug-info=%t.dSYM %t.proflite
+
+// RUN: diff <(llvm-profdata show --all-functions --counts %t.normal.profdata) <(llvm-profdata show --all-functions --counts %t.profdata)
+
+// RUN: llvm-cov report --instr-profile=%t.profdata %t | FileCheck %s -check-prefix=NONAME
+
+// Test debug info correlate with clang coverage (online merging).
+
+// RUN: env LLVM_PROFILE_FILE=%t-1.profraw %run %t.normal
+// RUN: env LLVM_PROFILE_FILE=%t-2.profraw %run %t.normal
+// RUN: llvm-profdata merge -o %t.normal.profdata %t-1.profraw %t-2.profraw
+
+// RUN: rm -rf %t.profdir && mkdir %t.profdir
+// RUN: env LLVM_PROFILE_FILE=%t.profdir/%m.proflite %run %t
+// RUN: env LLVM_PROFILE_FILE=%t.profdir/%m.proflite %run %t
+// RUN: llvm-profdata merge -o %t.profdata --debug-info=%t.dSYM %t.profdir
+
+// RUN: diff <(llvm-profdata show --all-functions --counts %t.normal.profdata) <(llvm-profdata show --all-functions --counts %t.profdata)
+
+// RUN: llvm-cov report --instr-profile=%t.profdata %t | FileCheck %s -check-prefix=NONAME
+// RUN: llvm-cov report --instr-profile=%t.normal.profdata %t | FileCheck %s -check-prefix=NONAME
+
+// NONAME:      Filename                                    Regions    Missed Regions     Cover   Functions  Missed Functions  Executed       Lines      Missed Lines     Cover    Branches   Missed Branches     Cover
+// NONAME-NEXT: --
+// NONAME-NEXT: instrprof-debug-info-correlate-bar.h              3                 1    66.67%           1                 0   100.00%           5                 1    80.00%           2                 1    50.00%
+// NONAME-NEXT: instrprof-debug-info-correlate-foo.cpp            5                 2    60.00%           2                 1    50.00%           6                 2    66.67%           2                 1    50.00%
+// NONAME-NEXT: instrprof-debug-info-correlate-main.cpp           4                 0   100.00%           1                 0   100.00%           5                 0   100.00%           2                 0   100.00%
+// NONAME-NEXT: --
+// NONAME-NEXT: TOTAL                                            12                 3    75.00%           4                 1    75.00%          16                 3    81.25%           6                 2    66.67%
+
+// Test the case when there is __llvm_prf_names in the binary (those are names of uninstrumented functions).
+// RUN: %clang_profgen -o %t.normal -fcoverage-mapping -mllvm -enable-name-compression=false %s
+// RUN: env LLVM_PROFILE_FILE=%t.profraw %run %t.normal
+// RUN: llvm-profdata merge -o %t.normal.profdata %t.profraw
+
+// RUN: %clang_profgen -o %t -g -mllvm --debug-info-correlate -fcoverage-mapping -mllvm -enable-name-compression=false %s
+// RUN: env LLVM_PROFILE_FILE=%t.proflite %run %t
+// RUN: llvm-profdata merge -o %t.profdata --debug-info=%t.dSYM %t.proflite
+
+// RUN: diff <(llvm-profdata show --all-functions --counts %t.normal.profdata) <(llvm-profdata show --all-functions --counts %t.profdata)
+
+// RUN: llvm-cov export --format=lcov --instr-profile=%t.profdata %t | FileCheck %s -check-prefix=NAME
+
+// Test debug info correlate with clang coverage (online merging).
+
+// RUN: env LLVM_PROFILE_FILE=%t-1.profraw %run %t.normal
+// RUN: env LLVM_PROFILE_FILE=%t-2.profraw %run %t.normal
+// RUN: llvm-profdata merge -o %t.normal.profdata %t-1.profraw %t-2.profraw
+
+// RUN: rm -rf %t.profdir && mkdir %t.profdir
+// RUN: env LLVM_PROFILE_FILE=%t.profdir/%m.proflite %run %t
+// RUN: env LLVM_PROFILE_FILE=%t.profdir/%m.proflite %run %t
+// RUN: llvm-profdata merge -o %t.profdata --debug-info=%t.dSYM %t.profdir
+
+// RUN: diff <(llvm-profdata show --all-functions --counts %t.normal.profdata) <(llvm-profdata show --all-functions --counts %t.profdata)
+
+// RUN: llvm-cov export --format=lcov --instr-profile=%t.profdata %t | FileCheck %s -check-prefix=NAME
+// NAME: _Z9used_funcv
+// NAME: main
+// NAME: _ZN1A11unused_funcEv
+
+struct A {
+  void unused_func() {}
+};
+void used_func() {}
+int main() {
+  used_func();
+  return 0;
+}

compiler-rt/test/profile/Linux/coverage-debug-info-correlate.cpp

+// Test debug info correlate with clang coverage.
+
+// Test the case when there is no __llvm_prf_names in the binary.
+// RUN: %clang_profgen -o %t.normal -fcoverage-mapping %S/../Inputs/instrprof-debug-info-correlate-main.cpp %S/../Inputs/instrprof-debug-info-correlate-foo.cpp
+// RUN: env LLVM_PROFILE_FILE=%t.profraw %run %t.normal
+// RUN: llvm-profdata merge -o %t.normal.profdata %t.profraw
+
+// RUN: %clang_profgen -o %t -g -mllvm --debug-info-correlate -fcoverage-mapping %S/../Inputs/instrprof-debug-info-correlate-main.cpp %S/../Inputs/instrprof-debug-info-correlate-foo.cpp
+// RUN: env LLVM_PROFILE_FILE=%t.proflite %run %t
+// RUN: llvm-profdata merge -o %t.profdata --debug-info=%t %t.proflite
+
+// RUN: diff <(llvm-profdata show --all-functions --counts %t.normal.profdata) <(llvm-profdata show --all-functions --counts %t.profdata)
+
+// RUN: llvm-cov report --instr-profile=%t.profdata %t | FileCheck %s -check-prefix=NONAME
+
+// Test debug info correlate with clang coverage (online merging).
+
+// RUN: env LLVM_PROFILE_FILE=%t-1.profraw %run %t.normal
+// RUN: env LLVM_PROFILE_FILE=%t-2.profraw %run %t.normal
+// RUN: llvm-profdata merge -o %t.normal.profdata %t-1.profraw %t-2.profraw
+
+// RUN: rm -rf %t.profdir && mkdir %t.profdir
+// RUN: env LLVM_PROFILE_FILE=%t.profdir/%m.proflite %run %t
+// RUN: env LLVM_PROFILE_FILE=%t.profdir/%m.proflite %run %t
+// RUN: llvm-profdata merge -o %t.profdata --debug-info=%t %t.profdir
+
+// RUN: diff <(llvm-profdata show --all-functions --counts %t.normal.profdata) <(llvm-profdata show --all-functions --counts %t.profdata)
+
+// RUN: llvm-cov report --instr-profile=%t.profdata %t | FileCheck %s -check-prefix=NONAME
+// RUN: llvm-cov report --instr-profile=%t.normal.profdata %t | FileCheck %s -check-prefix=NONAME
+
+// NONAME:      Filename                                    Regions    Missed Regions     Cover   Functions  Missed Functions  Executed       Lines      Missed Lines     Cover    Branches   Missed Branches     Cover
+// NONAME-NEXT: --
+// NONAME-NEXT: instrprof-debug-info-correlate-bar.h              3                 1    66.67%           1                 0   100.00%           5                 1    80.00%           2                 1    50.00%
+// NONAME-NEXT: instrprof-debug-info-correlate-foo.cpp            5                 2    60.00%           2                 1    50.00%           6                 2    66.67%           2                 1    50.00%
+// NONAME-NEXT: instrprof-debug-info-correlate-main.cpp           4                 0   100.00%           1                 0   100.00%           5                 0   100.00%           2                 0   100.00%
+// NONAME-NEXT: --
+// NONAME-NEXT: TOTAL                                            12                 3    75.00%           4                 1    75.00%          16                 3    81.25%           6                 2    66.67%
+
+// Test the case when there is __llvm_prf_names in the binary (those are names of uninstrumented functions).
+// RUN: %clang_profgen -o %t.normal -fcoverage-mapping -mllvm -enable-name-compression=false %s
+// RUN: env LLVM_PROFILE_FILE=%t.profraw %run %t.normal
+// RUN: llvm-profdata merge -o %t.normal.profdata %t.profraw
+
+// RUN: %clang_profgen -o %t -g -mllvm --debug-info-correlate -fcoverage-mapping -mllvm -enable-name-compression=false %s
+// RUN: env LLVM_PROFILE_FILE=%t.proflite %run %t
+// RUN: llvm-profdata merge -o %t.profdata --debug-info=%t %t.proflite
+
+// RUN: diff <(llvm-profdata show --all-functions --counts %t.normal.profdata) <(llvm-profdata show --all-functions --counts %t.profdata)
+
+// RUN: llvm-cov export --format=lcov --instr-profile=%t.profdata %t | FileCheck %s -check-prefix=NAME
+
+// Test debug info correlate with clang coverage (online merging).
+
+// RUN: env LLVM_PROFILE_FILE=%t-1.profraw %run %t.normal
+// RUN: env LLVM_PROFILE_FILE=%t-2.profraw %run %t.normal
+// RUN: llvm-profdata merge -o %t.normal.profdata %t-1.profraw %t-2.profraw
+
+// RUN: rm -rf %t.profdir && mkdir %t.profdir
+// RUN: env LLVM_PROFILE_FILE=%t.profdir/%m.proflite %run %t
+// RUN: env LLVM_PROFILE_FILE=%t.profdir/%m.proflite %run %t
+// RUN: llvm-profdata merge -o %t.profdata --debug-info=%t %t.profdir
+
+// RUN: diff <(llvm-profdata show --all-functions --counts %t.normal.profdata) <(llvm-profdata show --all-functions --counts %t.profdata)
+
+// RUN: llvm-cov export --format=lcov --instr-profile=%t.profdata %t | FileCheck %s -check-prefix=NAME
+// NAME: _Z9used_funcv
+// NAME: main
+// NAME: _ZN1A11unused_funcEv
+
+struct A {
+  void unused_func() {}
+};
+void used_func() {}
+int main() {
+  used_func();
+  return 0;
+}

llvm/include/llvm/ProfileData/Coverage/CoverageMappingReader.h

private:
   BinaryCoverageReader(FuncRecordsStorage &&FuncRecords)
       : FuncRecords(std::move(FuncRecords)) {}
 
 public:
   BinaryCoverageReader(const BinaryCoverageReader &) = delete;
   BinaryCoverageReader &operator=(const BinaryCoverageReader &) = delete;
 
   static Expected<std::vector<std::unique_ptr<BinaryCoverageReader>>>
-  create(MemoryBufferRef ObjectBuffer, StringRef Arch,
+  create(MemoryBufferRef ObjectBuffer, IndexedInstrProfReader &ProfileReader,
+         StringRef Arch,
          SmallVectorImpl<std::unique_ptr<MemoryBuffer>> &ObjectFileBuffers,
          StringRef CompilationDir = "",
          SmallVectorImpl<object::BuildIDRef> *BinaryIDs = nullptr);
 
   static Expected<std::unique_ptr<BinaryCoverageReader>>
   createCoverageReaderFromBuffer(StringRef Coverage,
                                  FuncRecordsStorage &&FuncRecords,
                                  InstrProfSymtab &&ProfileNames,

llvm/include/llvm/ProfileData/InstrProfCorrelator.h

public:
   static llvm::Expected<std::unique_ptr<InstrProfCorrelator>>
   get(StringRef DebugInfoFilename);
 
   /// Construct a ProfileData vector used to correlate raw instrumentation data
   /// to their functions.
   /// \param MaxWarnings the maximum number of warnings to emit (0 = no limit)
   virtual Error correlateProfileData(int MaxWarnings) = 0;
 
+  virtual Error correlateCovUnusedFuncNames(int MaxWarnings) = 0;
+
   /// Process debug info and dump the correlation data.
   /// \param MaxWarnings the maximum number of warnings to emit (0 = no limit)
   virtual Error dumpYaml(int MaxWarnings, raw_ostream &OS) = 0;
 
   /// Return the number of ProfileData elements.
   std::optional<size_t> getDataSize() const;
 
   /// Return a pointer to the names string that this class constructs.
   const char *getNamesPointer() const { return Names.c_str(); }
 
   /// Return the number of bytes in the names string.
   size_t getNamesSize() const { return Names.size(); }
 
+  const char *getCovUnusedFuncNamesPointer() const {
+    return CovUnusedFuncNames.c_str();
+  }
+
+  size_t getCovUnusedFuncNamesSize() const { return CovUnusedFuncNames.size(); }
+
   /// Return the size of the counters section in bytes.
   uint64_t getCountersSectionSize() const {
     return Ctx->CountersSectionEnd - Ctx->CountersSectionStart;
   }
 
   static const char *FunctionNameAttributeName;
   static const char *CFGHashAttributeName;
   static const char *NumCountersAttributeName;
+  static const char *CovFunctionNameAttributeName;
 
   enum InstrProfCorrelatorKind { CK_32Bit, CK_64Bit };
   InstrProfCorrelatorKind getKind() const { return Kind; }
   virtual ~InstrProfCorrelator() = default;
 
 protected:
   struct Context {
     static llvm::Expected<std::unique_ptr<Context>>
     get(std::unique_ptr<MemoryBuffer> Buffer, const object::ObjectFile &Obj);
     std::unique_ptr<MemoryBuffer> Buffer;
     /// The address range of the __llvm_prf_cnts section.
     uint64_t CountersSectionStart;
     uint64_t CountersSectionEnd;
     /// True if target and host have different endian orders.
     bool ShouldSwapBytes;
   };
   const std::unique_ptr<Context> Ctx;
 
   InstrProfCorrelator(InstrProfCorrelatorKind K, std::unique_ptr<Context> Ctx)
       : Ctx(std::move(Ctx)), Kind(K) {}
 
   std::string Names;
   std::vector<std::string> NamesVec;
+  std::string CovUnusedFuncNames;
 
   struct Probe {
     std::string FunctionName;
     std::optional<std::string> LinkageName;
     yaml::Hex64 CFGHash;
     yaml::Hex64 CounterOffset;
     uint32_t NumCounters;
     std::optional<std::string> FilePath;
private:
   ///       NULL
   ///     NULL
   /// \endcode
   /// \param MaxWarnings the maximum number of warnings to emit (0 = no limit)
   /// \param Data if provided, populate with the correlation data found
   void correlateProfileDataImpl(
       int MaxWarnings,
       InstrProfCorrelator::CorrelationData *Data = nullptr) override;
+
+  Error correlateCovUnusedFuncNames(int MaxWarnings) override;
 };
 
 } // end namespace llvm
 
 #endif // LLVM_PROFILEDATA_INSTRPROFCORRELATOR_H

llvm/lib/ProfileData/Coverage/CoverageMapping.cpp

Error CoverageMapping::loadFromFile(
   if (std::error_code EC = CovMappingBufOrErr.getError())
     return createFileError(Filename, errorCodeToError(EC));
   MemoryBufferRef CovMappingBufRef =
       CovMappingBufOrErr.get()->getMemBufferRef();
   SmallVector<std::unique_ptr<MemoryBuffer>, 4> Buffers;
 
   SmallVector<object::BuildIDRef> BinaryIDs;
   auto CoverageReadersOrErr = BinaryCoverageReader::create(
-      CovMappingBufRef, Arch, Buffers, CompilationDir,
+      CovMappingBufRef, ProfileReader, Arch, Buffers, CompilationDir,
       FoundBinaryIDs ? &BinaryIDs : nullptr);
   if (Error E = CoverageReadersOrErr.takeError()) {
     E = handleMaybeNoDataFoundError(std::move(E));
     if (E)
       return createFileError(Filename, std::move(E));
     return E;
   }
 

llvm/lib/ProfileData/Coverage/CoverageMappingReader.cpp

 #include "llvm/ADT/StringRef.h"
 #include "llvm/Object/Archive.h"
 #include "llvm/Object/Binary.h"
 #include "llvm/Object/COFF.h"
 #include "llvm/Object/Error.h"
 #include "llvm/Object/MachOUniversal.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/ProfileData/InstrProf.h"
+#include "llvm/ProfileData/InstrProfReader.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Compression.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/MathExtras.h"
for (const auto &Section : OF.sections()) {
     if (stripSuffix(*NameOrErr) == Name)
       Sections.push_back(Section);
   }
   if (Sections.empty())
     return make_error<CoverageMapError>(coveragemap_error::no_data_found);
   return Sections;
 }
 
+static Error getProfileNamesFromDebugInfo(StringRef FileName,
+                                          InstrProfSymtab &ProfileNames) {
+  std::unique_ptr<InstrProfCorrelator> Correlator;
+  if (auto E = InstrProfCorrelator::get(FileName).moveInto(Correlator))
+    return E;
+  if (auto E = Correlator->correlateCovUnusedFuncNames(0))
+    return E;
+  if (auto E = ProfileNames.create(
+          StringRef(Correlator->getCovUnusedFuncNamesPointer(),
+                    Correlator->getCovUnusedFuncNamesSize())))
+    return E;
+  return Error::success();
+}
+
 static Expected<std::unique_ptr<BinaryCoverageReader>>
-loadBinaryFormat(std::unique_ptr<Binary> Bin, StringRef Arch,
+loadBinaryFormat(std::unique_ptr<Binary> Bin,
+                 IndexedInstrProfReader &ProfileReader, StringRef Arch,
                  StringRef CompilationDir = "",
                  object::BuildIDRef *BinaryID = nullptr) {
   std::unique_ptr<ObjectFile> OF;
   if (auto *Universal = dyn_cast<MachOUniversalBinary>(Bin.get())) {
     // If we have a universal binary, try to look up the object for the
     // appropriate architecture.
     auto ObjectFileOrErr = Universal->getMachOObjectForArch(Arch);
     if (!ObjectFileOrErr)
loadBinaryFormat(std::unique_ptr<Binary> Bin,
   // The coverage uses native pointer sizes for the object it's written in.
   uint8_t BytesInAddress = OF->getBytesInAddress();
   support::endianness Endian = OF->isLittleEndian()
                                    ? support::endianness::little
                                    : support::endianness::big;
 
   // Look for the sections that we are interested in.
   auto ObjFormat = OF->getTripleObjectFormat();
+  InstrProfSymtab ProfileNames = ProfileReader.getSymtab();
   auto NamesSection =
       lookupSections(*OF, getInstrProfSectionName(IPSK_name, ObjFormat,
                                                   /*AddSegmentInfo=*/false));
-  if (auto E = NamesSection.takeError())
+  if (auto E = NamesSection.takeError()) {
+    if (OF->hasDebugInfo()) {
+      if (auto E =
+              getProfileNamesFromDebugInfo(OF->getFileName(), ProfileNames))
+        return make_error<CoverageMapError>(coveragemap_error::malformed);
+    }
+    consumeError(std::move(E));
+  } else {
+    std::vector<SectionRef> NamesSectionRefs = *NamesSection;
+    if (NamesSectionRefs.size() != 1)
+      return make_error<CoverageMapError>(coveragemap_error::malformed);
+    if (Error E = ProfileNames.create(NamesSectionRefs.back()))
       return std::move(E);
+  }
   auto CoverageSection =
       lookupSections(*OF, getInstrProfSectionName(IPSK_covmap, ObjFormat,
                                                   /*AddSegmentInfo=*/false));
   if (auto E = CoverageSection.takeError())
     return std::move(E);
   std::vector<SectionRef> CoverageSectionRefs = *CoverageSection;
   if (CoverageSectionRefs.size() != 1)
     return make_error<CoverageMapError>(coveragemap_error::malformed,
                                         "the size of name section is not one");
   auto CoverageMappingOrErr = CoverageSectionRefs.back().getContents();
   if (!CoverageMappingOrErr)
     return CoverageMappingOrErr.takeError();
   StringRef CoverageMapping = CoverageMappingOrErr.get();
 
-  InstrProfSymtab ProfileNames;
-  std::vector<SectionRef> NamesSectionRefs = *NamesSection;
-  if (NamesSectionRefs.size() != 1)
-    return make_error<CoverageMapError>(
-        coveragemap_error::malformed,
-        "the size of coverage mapping section is not one");
-  if (Error E = ProfileNames.create(NamesSectionRefs.back()))
-    return std::move(E);
-
   // Look for the coverage records section (Version4 only).
   auto CoverageRecordsSections =
       lookupSections(*OF, getInstrProfSectionName(IPSK_covfun, ObjFormat,
                                                   /*AddSegmentInfo=*/false));
 
   BinaryCoverageReader::FuncRecordsStorage FuncRecords;
   if (auto E = CoverageRecordsSections.takeError()) {
     consumeError(std::move(E));
for (auto &ObjForArch : Universal->objects())
         return false;
     return true;
   }
   return false;
 }
 
 Expected<std::vector<std::unique_ptr<BinaryCoverageReader>>>
 BinaryCoverageReader::create(
-    MemoryBufferRef ObjectBuffer, StringRef Arch,
+    MemoryBufferRef ObjectBuffer, IndexedInstrProfReader &ProfileReader,
+    StringRef Arch,
     SmallVectorImpl<std::unique_ptr<MemoryBuffer>> &ObjectFileBuffers,
     StringRef CompilationDir, SmallVectorImpl<object::BuildIDRef> *BinaryIDs) {
   std::vector<std::unique_ptr<BinaryCoverageReader>> Readers;
 
   if (ObjectBuffer.getBuffer().size() > sizeof(TestingFormatMagic)) {
     uint64_t Magic =
         support::endian::byte_swap<uint64_t, support::endianness::little>(
             *reinterpret_cast<const uint64_t *>(ObjectBuffer.getBufferStart()));
for (auto &ObjForArch : Universal->objects()) {
       auto ArchiveOrErr = ObjForArch.getAsArchive();
       if (!ArchiveOrErr) {
         // If this is not an archive, try treating it as a regular object.
         consumeError(ArchiveOrErr.takeError());
         break;
       }
 
       return BinaryCoverageReader::create(
-          ArchiveOrErr.get()->getMemoryBufferRef(), Arch, ObjectFileBuffers,
-          CompilationDir, BinaryIDs);
+          ArchiveOrErr.get()->getMemoryBufferRef(), ProfileReader, Arch,
+          ObjectFileBuffers, CompilationDir, BinaryIDs);
     }
   }
 
   // Load coverage out of archive members.
   if (auto *Ar = dyn_cast<Archive>(Bin.get())) {
     Error Err = Error::success();
     for (auto &Child : Ar->children(Err)) {
       Expected<MemoryBufferRef> ChildBufOrErr = Child.getMemoryBufferRef();
       if (!ChildBufOrErr)
         return ChildBufOrErr.takeError();
 
       auto ChildReadersOrErr = BinaryCoverageReader::create(
-          ChildBufOrErr.get(), Arch, ObjectFileBuffers, CompilationDir,
-          BinaryIDs);
+          ChildBufOrErr.get(), ProfileReader, Arch, ObjectFileBuffers,
+          CompilationDir, BinaryIDs);
       if (!ChildReadersOrErr)
         return ChildReadersOrErr.takeError();
       for (auto &Reader : ChildReadersOrErr.get())
         Readers.push_back(std::move(Reader));
     }
     if (Err)
       return std::move(Err);
 
     // Thin archives reference object files outside of the archive file, i.e.
     // files which reside in memory not owned by the caller. Transfer ownership
     // to the caller.
     if (Ar->isThin())
       for (auto &Buffer : Ar->takeThinBuffers())
         ObjectFileBuffers.push_back(std::move(Buffer));
 
     return std::move(Readers);
   }
 
   object::BuildIDRef BinaryID;
-  auto ReaderOrErr = loadBinaryFormat(std::move(Bin), Arch, CompilationDir,
-                                      BinaryIDs ? &BinaryID : nullptr);
+  auto ReaderOrErr =
+      loadBinaryFormat(std::move(Bin), ProfileReader, Arch, CompilationDir,
   if (!ReaderOrErr)
     return ReaderOrErr.takeError();
   Readers.push_back(std::move(ReaderOrErr.get()));
   if (!BinaryID.empty())
     BinaryIDs->push_back(BinaryID);
   return std::move(Readers);
 }
 

llvm/lib/ProfileData/InstrProfCorrelator.cpp

Expected<object::SectionRef> getCountersSection(const object::ObjectFile &Obj) {
   return make_error<InstrProfError>(
       instrprof_error::unable_to_correlate_profile,
       "could not find counter section (" INSTR_PROF_CNTS_SECT_NAME ")");
 }
 
 const char *InstrProfCorrelator::FunctionNameAttributeName = "Function Name";
 const char *InstrProfCorrelator::CFGHashAttributeName = "CFG Hash";
 const char *InstrProfCorrelator::NumCountersAttributeName = "Num Counters";
+const char *InstrProfCorrelator::CovFunctionNameAttributeName =
+    "Cov Function Name";
 
 llvm::Expected<std::unique_ptr<InstrProfCorrelator::Context>>
 InstrProfCorrelator::Context::get(std::unique_ptr<MemoryBuffer> Buffer,
                                   const object::ObjectFile &Obj) {
   auto CountersSection = getCountersSection(Obj);
   if (auto Err = CountersSection.takeError())
     return std::move(Err);
   auto C = std::make_unique<Context>();
void DwarfInstrProfCorrelator<IntPtrT>::correlateProfileDataImpl(
   for (auto &CU : DICtx->dwo_units())
     for (const auto &Entry : CU->dies())
       maybeAddProbe(DWARFDie(CU.get(), &Entry));
 
   if (!UnlimitedWarnings && NumSuppressedWarnings > 0)
     WithColor::warning() << format("Suppressed %d additional warnings\n",
                                    NumSuppressedWarnings);
 }
+
+template <class IntPtrT>
+Error DwarfInstrProfCorrelator<IntPtrT>::correlateCovUnusedFuncNames(
+    int MaxWarnings) {
+  bool UnlimitedWarnings = (MaxWarnings == 0);
+  // -N suppressed warnings means we can emit up to N (unsuppressed) warnings
+  int NumSuppressedWarnings = -MaxWarnings;
+  std::vector<std::string> UnusedFuncNames;
+  auto IsDIEOfCovName = [](const DWARFDie &Die) {
+    const auto &ParentDie = Die.getParent();
+    if (!Die.isValid() || !ParentDie.isValid() || Die.isNULL())
+      return false;
+    if (Die.getTag() != dwarf::DW_TAG_variable)
+      return false;
+    if (ParentDie.getParent().isValid())
+      return false;
+    if (!Die.hasChildren())
+      return false;
+    if (const char *Name = Die.getName(DINameKind::ShortName))
+      return StringRef(Name).startswith(getCoverageUnusedNamesVarName());
+    return false;
+  };
+  auto MaybeAddCovFuncName = [&](DWARFDie Die) {
+    if (!IsDIEOfCovName(Die))
+      return;
+    for (const DWARFDie &Child : Die.children()) {
+      if (Child.getTag() != dwarf::DW_TAG_LLVM_annotation)
+        continue;
+      auto AnnotationFormName = Child.find(dwarf::DW_AT_name);
+      auto AnnotationFormValue = Child.find(dwarf::DW_AT_const_value);
+      if (!AnnotationFormName || !AnnotationFormValue)
+        continue;
+      auto AnnotationNameOrErr = AnnotationFormName->getAsCString();
+      if (auto Err = AnnotationNameOrErr.takeError()) {
+        consumeError(std::move(Err));
+        continue;
+      }
+      std::optional<const char *> FunctionName;
+      StringRef AnnotationName = *AnnotationNameOrErr;
+      if (AnnotationName.compare(
+              InstrProfCorrelator::CovFunctionNameAttributeName) == 0) {
+        if (auto EC =
+                AnnotationFormValue->getAsCString().moveInto(FunctionName))
+          consumeError(std::move(EC));
+      }
+      if (!FunctionName) {
+        if (UnlimitedWarnings || ++NumSuppressedWarnings < 1) {
+          WithColor::warning() << format(
+              "Missing coverage function name value at DIE 0x%08" PRIx64,
+              Child.getOffset());
+        }
+        return;
+      }
+      UnusedFuncNames.push_back(*FunctionName);
+    }
+  };
+  for (auto &CU : DICtx->normal_units())
+    for (const auto &Entry : CU->dies())
+      MaybeAddCovFuncName(DWARFDie(CU.get(), &Entry));
+  for (auto &CU : DICtx->dwo_units())
+    for (const auto &Entry : CU->dies())
+      MaybeAddCovFuncName(DWARFDie(CU.get(), &Entry));
+
+  if (!UnlimitedWarnings && NumSuppressedWarnings > 0)
+    WithColor::warning() << format("Suppressed %d additional warnings\n",
+                                   NumSuppressedWarnings);
+  if (!UnusedFuncNames.empty()) {
+    auto Result = collectPGOFuncNameStrings(
+        UnusedFuncNames, /*doCompression=*/false, this->CovUnusedFuncNames);
+    return Result;
+  }
+  return Error::success();
+}

llvm/lib/Transforms/Instrumentation/InstrProfiling.cpp

for (unsigned I = 0, E = Names->getNumOperands(); I < E; ++I) {
     assert(isa<GlobalVariable>(V) && "Missing reference to function name");
     GlobalVariable *Name = cast<GlobalVariable>(V);
 
     Name->setLinkage(GlobalValue::PrivateLinkage);
     ReferencedNames.push_back(Name);
     if (isa<ConstantExpr>(NC))
       NC->dropAllReferences();
   }
+  if (DebugInfoCorrelate && !ReferencedNames.empty()) {
+    MDNode *Node = *M->debug_compile_units_begin();
+    DICompileUnit *CU = cast<DICompileUnit>(Node);
+    DIBuilder DB(*M, true, CU);
+    LLVMContext &Ctx = M->getContext();
+    SmallVector<llvm::Metadata *> Annots;
+    for (auto *NameVar: ReferencedNames) {
+      Metadata *CovFunctionNameAnnotation[] = {
+          MDString::get(Ctx, InstrProfCorrelator::CovFunctionNameAttributeName),
+          MDString::get(Ctx,
+                        std::string(getPGOFuncNameVarInitializer(NameVar))),
+      };
+      Annots.push_back(MDNode::get(Ctx, CovFunctionNameAnnotation));
+    }
+    auto Annotations = DB.getOrCreateArray(Annots);
+    auto *DICovName = DB.createGlobalVariableExpression(
+        CU, CoverageNamesVar->getName(), /*LinkageName=*/StringRef(),
+        CU->getFile(),
+        /*LineNo=*/0, DB.createUnspecifiedType("Coverage Type"),
+        /*IsLocalToUnit=*/true, /*IsDefined=*/true, /*Expr=*/nullptr,
+        /*Decl=*/nullptr, /*TemplateParams=*/nullptr, /*AlignInBits=*/0,
+        Annotations);
+    CoverageNamesVar->addDebugInfo(DICovName);
+    DB.finalize();
+    ReferencedNames.clear();
+    return;
+  }
+
   CoverageNamesVar->eraseFromParent();
 }
 
 /// Get the name of a profiling variable for a particular function.
 static std::string getVarName(InstrProfInstBase *Inc, StringRef Prefix,
                               bool &Renamed) {
   StringRef NamePrefix = getInstrProfNameVarPrefix();
   StringRef Name = Inc->getName()->getName().substr(NamePrefix.size());

llvm/test/Instrumentation/InstrProfiling/debug-info-correlate-clang-coverage.ll

+; Test if unused function names are correctly emitted as dwarf variable debug info under DW_TAG_compile_unit
+
+; RUN: opt < %s -passes=instrprof -debug-info-correlate -S > %t.ll
+; RUN: FileCheck < %t.ll --implicit-check-not "{{__llvm_prf_data|__llvm_prf_names}}" %s
+; RUN: %llc_dwarf -O0 -filetype=obj < %t.ll | llvm-dwarfdump - | FileCheck %s --check-prefix=CHECK-DWARF
+
+; REQUIRES: system-linux, object-emission
+
+@__profn_foo = private constant [3 x i8] c"foo"
+@__profn_bar = private constant [3 x i8] c"bar"
+@__profn_baz = private constant [3 x i8] c"baz"
+@__llvm_coverage_names = internal constant [2 x ptr] [ptr @__profn_bar, ptr @__profn_baz]
+; CHECK: @__llvm_coverage_names = internal constant [2 x ptr] [ptr @__profn_bar, ptr @__profn_baz], !dbg ![[DBG:[0-9]+]]
+; CHECK: ![[DBG]] = !DIGlobalVariableExpression(var: ![[VAR:[0-9]+]], expr: !DIExpression())
+; CHECK: ![[VAR]] = {{.*}} !DIGlobalVariable(name: "__llvm_coverage_names"
+; CHECK-SAME: scope: ![[SCOPE:[0-9]+]]
+; CHECK-SAME: annotations: ![[ANNOTATIONS:[0-9]+]]
+; CHECK: ![[SCOPE]] = {{.*}} !DICompileUnit(
+; CHECK: ![[ANNOTATIONS]] = !{![[FUNC_NAME1:[0-9]+]], ![[FUNC_NAME2:[0-9]+]]}
+; CHECK: ![[FUNC_NAME1]] = !{!"Cov Function Name", !"bar"}
+; CHECK: ![[FUNC_NAME2]] = !{!"Cov Function Name", !"baz"}
+
+define void @_Z3foov() !dbg !12 {
+  call void @llvm.instrprof.increment(ptr @__profn_foo, i64 12345678, i32 2, i32 0)
+  ret void
+}
+
+declare void @llvm.instrprof.increment(ptr, i64, i32, i32)
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!2, !3, !4, !5, !6, !7, !8, !9, !10}
+!llvm.ident = !{!11}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !1, producer: "clang version 14.0.0", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, splitDebugInlining: false, nameTableKind: None)
+!1 = !DIFile(filename: "debug-info-correlate.cpp", directory: "")
+!2 = !{i32 7, !"Dwarf Version", i32 4}
+!3 = !{i32 2, !"Debug Info Version", i32 3}
+!4 = !{i32 1, !"wchar_size", i32 4}
+!5 = !{i32 8, !"branch-target-enforcement", i32 0}
+!6 = !{i32 8, !"sign-return-address", i32 0}
+!7 = !{i32 8, !"sign-return-address-all", i32 0}
+!8 = !{i32 8, !"sign-return-address-with-bkey", i32 0}
+!9 = !{i32 7, !"uwtable", i32 1}
+!10 = !{i32 7, !"frame-pointer", i32 1}
+!11 = !{!"clang version 14.0.0"}
+!12 = distinct !DISubprogram(name: "foo", linkageName: "_Z3foov", scope: !13, file: !13, line: 1, type: !14, scopeLine: 1, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !0, retainedNodes: !16)
+!13 = !DIFile(filename: "debug-info-correlate.cpp", directory: "")
+!14 = !DISubroutineType(types: !15)
+!15 = !{null}
+!16 = !{}
+
+; CHECK-DWARF: DW_TAG_compile_unit
+; CHECK-DWARF:   DW_TAG_variable
+; CHECK-DWARF:     DW_AT_name ("__llvm_coverage_names")
+; CHECK-DWARF:     DW_AT_type ({{.*}} "Coverage Type")
+; CHECK-DWARF:     DW_TAG_LLVM_annotation
+; CHECK-DWARF:       DW_AT_name ("Cov Function Name")
+; CHECK-DWARF:       DW_AT_const_value  ("bar")
+; CHECK-DWARF:     DW_TAG_LLVM_annotation
+; CHECK-DWARF:       DW_AT_name ("Cov Function Name")
+; CHECK-DWARF:       DW_AT_const_value  ("baz")
+; CHECK-DWARF:   DW_TAG_unspecified_type
+; CHECK-DWARF:     DW_AT_name ("Coverage Type")
+; CHECK-DWARF:   NULL