[IRGen] Emit name data for unused coverage counters

Previously, if all the coverage counters for a
given SIL function were optimized out, we would
have dropped the coverage map on the floor,
leading to inaccurate coverage reports in `-O`.
However LLVM allows us to emit the name data for
the coverage maps separately by defining an
`__llvm_coverage_names` global with the name data,
which is picked up by its instrumentation lowering
pass. Use this to continue to emit coverage maps
for functions that do not get emitted.

rdar://99813754

Author: hamishknight

lib/IRGen/GenCoverage.cpp

@@ -43,23 +43,41 @@ static std::string getInstrProfSection(IRGenModule &IGM,
 }
 
 void IRGenModule::emitCoverageMapping() {
+  SmallVector<llvm::Constant *, 4> UnusedFuncNames;
   std::vector<const SILCoverageMap *> Mappings;
   for (const auto &M : getSILModule().getCoverageMaps()) {
+    auto FuncName = M.second->getPGOFuncName();
+    auto VarLinkage = llvm::GlobalValue::LinkOnceAnyLinkage;
+    auto FuncNameVarName = llvm::getPGOFuncNameVarName(FuncName, VarLinkage);
+
     // Check whether this coverage mapping can reference its name data within
-    // the profile symbol table. If the name global is gone, this function has
-    // been optimized out.
-    StringRef PGOFuncName = M.second->getPGOFuncName();
-    std::string PGOFuncNameVar = llvm::getPGOFuncNameVarName(
-        PGOFuncName, llvm::GlobalValue::LinkOnceAnyLinkage);
-    if (!Module.getNamedGlobal(PGOFuncNameVar))
-      continue;
+    // the profile symbol table. If the name global isn't there, this function
+    // has been optimized out. We need to tell LLVM about it by emitting the
+    // name data separately.
+    if (!Module.getNamedGlobal(FuncNameVarName)) {
+      auto *Var = llvm::createPGOFuncNameVar(Module, VarLinkage, FuncName);
+      UnusedFuncNames.push_back(llvm::ConstantExpr::getBitCast(Var, Int8PtrTy));
+    }
     Mappings.push_back(M.second);
   }
 
   // If there aren't any coverage maps, there's nothing to emit.
   if (Mappings.empty())
     return;
 
+  // Emit the name data for any unused functions.
+  if (!UnusedFuncNames.empty()) {
+    auto NamePtrsTy = llvm::ArrayType::get(Int8PtrTy, UnusedFuncNames.size());
+    auto NamePtrs = llvm::ConstantArray::get(NamePtrsTy, UnusedFuncNames);
+
+    // Note we don't mark this variable as used, as it doesn't need to be
+    // present in the object file, it gets picked up by the LLVM instrumentation
+    // lowering pass.
+    new llvm::GlobalVariable(Module, NamePtrsTy, /*IsConstant*/ true,
+                             llvm::GlobalValue::InternalLinkage, NamePtrs,
+                             llvm::getCoverageUnusedNamesVarName());
+  }
+
   std::vector<StringRef> Files;
   for (const auto &M : Mappings)
     if (std::find(Files.begin(), Files.end(), M->getFile()) == Files.end())

test/Profiler/coverage_optimized.swift

@@ -0,0 +1,51 @@
+// RUN: %target-swift-frontend -emit-irgen  -profile-generate -profile-coverage-mapping -O -module-name coverage_optimized %s | %FileCheck %s -check-prefix IRGEN
+// RUN: %target-swift-frontend -emit-ir -profile-generate -profile-coverage-mapping -O -module-name coverage_optimized %s | %FileCheck %s -check-prefix IR
+
+// The functions 'unused' and 'optimizedOut' below will be optimized out, but
+// make sure we still emit coverage records for them, using name data emitted
+// separately in @__llvm_coverage_names.
+
+// IRGEN: @__llvm_coverage_names {{.*}} @"__profn_{{.*}}$s18coverage_optimized6unusedyyF", {{.*}} @"__profn_{{.*}}$s18coverage_optimized0B3OutSiyF"
+
+// IRGEN: @__covrec
+// IRGEN: @__covrec
+// IRGEN: @__covrec
+// IRGEN: @__covrec
+// IRGEN: @__covrec
+
+// IRGEN: @__llvm_coverage_mapping
+
+// IR: @__covrec
+// IR: @__covrec
+// IR: @__covrec
+// IR: @__covrec
+// IR: @__covrec
+
+// We shouldn't have any lingering @__profn's, they should have been emitted as
+// @__llvm_prf_nm.
+// IR-NOT: __profn_
+// IR-NOT: @__llvm_coverage_names
+// IR: @__llvm_prf_nm
+// IR-NOT: __profn_
+// IR-NOT: @__llvm_coverage_names
+
+// IR-NOT: define {{.*}} @"$s18coverage_optimized6unusedyyF"
+// IR-NOT: define {{.*}} @"$s18coverage_optimized0B3OutSiyF"
+
+func unused() {}
+func optimizedOut() -> Int { .random() ? 1 : 2 }
+
+func bar() -> Bool { false }
+
+func baz() {
+  if bar() {
+    _ = optimizedOut()
+  }
+}
+
+baz()
+
+// IRGEN-LABEL: define {{.*}} @main
+// IRGEN:       call void @llvm.instrprof.increment({{.*}} @"__profn_{{.*}}__tlcd_line
+// IRGEN:       call void @llvm.instrprof.increment({{.*}} @"__profn_{{.*}}$s18coverage_optimized3bazyyF"
+// IRGEN:       call void @llvm.instrprof.increment({{.*}} @"__profn_{{.*}}$s18coverage_optimized3barSbyF"

test/Profiler/coverage_optimized_report.swift

@@ -0,0 +1,33 @@
+// RUN: %empty-directory(%t)
+
+// RUN: %target-build-swift %s -profile-generate -profile-coverage-mapping -O -o %t/main
+
+// This unusual use of 'sh' allows the path of the profraw file to be
+// substituted by %target-run.
+// RUN: %target-codesign %t/main
+// RUN: %target-run sh -c 'env LLVM_PROFILE_FILE=$1 $2' -- %t/default.profraw %t/main
+
+// RUN: %llvm-profdata merge %t/default.profraw -o %t/default.profdata
+// RUN: %llvm-cov export -summary-only %t/main -instr-profile=%t/default.profdata | %FileCheck %s
+
+// REQUIRES: profile_runtime
+// REQUIRES: executable_test
+// REQUIRES: OS=macosx
+
+// CHECK: "lines":{"count":9,"covered":6{{.*}}"functions":{"count":5,"covered":3
+
+// The functions 'unused' and 'optimizedOut' will be optimized out, but
+// make sure we still emit coverage records for them, using name data emitted
+// separately in @__llvm_coverage_names.
+func unused() {}
+func optimizedOut() -> Int { .random() ? 1 : 2 }
+
+func bar() -> Bool { false }
+
+func baz() {
+  if bar() {
+    _ = optimizedOut()
+  }
+}
+
+baz()