[Coverage]: Fixing bug: -fcoverage-mapping does not work with gc-sections

[davidxl]

Summary

(The patch is intended for discussion purpose only)

With linker gc turned on, the linker will happily discard all __llvm_covmap sections from input objects so resulting executable file won't be usable with llvm-cov tool -- missing coverage data.

To demonstrate the problem, build a program with -fprofile-instr-generate -fcoverage-mapping -Wl,--gc-sections. The resulting exec won't be usable for coverage data dumping.

This patch shows one way to to fix the problem (demonstrated for Linux/FreeBSD only here). The idea is to force referencing coverage data module headers in profile dumper routines.

There are a couple of downsides:

1. it works for linux/freeBSD, and can be extended for Darwin. Supporting on other platforms can be more complicated -- need runtime registration of coverage data start/end
2. increases runtime overhead (physical memory and dumping time)

Another much better possible solution (verified manually on Linux) is quite simple -- set __llvm_covmap section with the right attributes such that they are not allocatable. When a section does not have the 'a' bit in attribute, the linker won't garbage collect it (just like debug sections).

This method has another added benefit --- process virtual memory size is reduced and the covmap section is now strippable. I think we should go with this approach instead (at least for ELF based systems). Thoughts?

[vsk]

This discussion is stale, and I'm closing it to clear out my queue.

David implemented this for ELF. There isn't a simple way to mark sections as non-allocatable on MachO. We don't have the gc-sections issue on Darwin, but I am planning on improving the dead-stripping situation there at some point.

lib/profile/InstrProfiling.h

 #include "InstrProfData.inc"
 } __llvm_profile_data;
 
 typedef struct __llvm_profile_header {
 #define INSTR_PROF_RAW_HEADER(Type, Name, Initializer) Type Name;
 #include "InstrProfData.inc"
 } __llvm_profile_header;
 
+typedef struct __llvm_covmap_header {
+#define COVMAP_HEADER(Type, LLVMType, Name, Initializer) Type Name;
+#include "InstrProfData.inc"
+} __llvm_covmap_header;
+
+typedef struct __llvm_covmap_func_record {
+#define COVMAP_FUNC_RECORD(Type, LLVMType, Name, Initializer) Type Name;
+#include "InstrProfData.inc"
+} __llvm_covmap_func_record;
+
 /*!
  * \brief Get number of bytes necessary to pad the argument to eight
  * byte boundary.
  */
 uint8_t __llvm_profile_get_num_padding_bytes(uint64_t SizeInBytes);
 
 /*!
  * \brief Get required size for profile buffer.

 int __llvm_profile_write_buffer(char *Buffer);
 
 const __llvm_profile_data *__llvm_profile_begin_data(void);
 const __llvm_profile_data *__llvm_profile_end_data(void);
 const char *__llvm_profile_begin_names(void);
 const char *__llvm_profile_end_names(void);
 uint64_t *__llvm_profile_begin_counters(void);
 uint64_t *__llvm_profile_end_counters(void);
+const __llvm_covmap_header *__llvm_profile_begin_covmap(void);
+const __llvm_covmap_header *__llvm_profile_end_covmap(void);
 
 /*!
  * \brief Clear profile counters to zero.
  *
  */
 void __llvm_profile_reset_counters(void);
 
 /*!

lib/profile/InstrProfilingFile.c

void __llvm_profile_override_default_filename(const char *Filename) {
   const char *Env_Filename = getenv("LLVM_PROFILE_FILE");
   if (Env_Filename && Env_Filename[0])
     return;
   setFilenamePossiblyWithPid(Filename);
 }
 
 COMPILER_RT_VISIBILITY
 int __llvm_profile_write_file(void) {
+  __llvm_covmap_header *CovHeader;
   int rc;
 
   GetEnvHook = &getenv;
   /* Check the filename. */
   if (!__llvm_profile_CurrentFilename) {
     PROF_ERR("LLVM Profile: Failed to write file : %s\n", "Filename not set");
     return -1;
   }
 
   /* Check if there is llvm/runtime version mismatch.  */
   if (GET_VERSION(__llvm_profile_get_version()) != INSTR_PROF_RAW_VERSION) {
     PROF_ERR("LLVM Profile: runtime and instrumentation version mismatch : "
              "expected %d, but get %d\n",
              INSTR_PROF_RAW_VERSION,
              (int)GET_VERSION(__llvm_profile_get_version()));
     return -1;
   }
 
   /* Write the file. */
   rc = writeFileWithName(__llvm_profile_CurrentFilename);
   if (rc)
     PROF_ERR("LLVM Profile: Failed to write file \"%s\": %s\n",
              __llvm_profile_CurrentFilename, strerror(errno));
+
+  /* Force reference to coverage data.  */
+  for (CovHeader = __llvm_profile_begin_covmap();
+       CovHeader < __llvm_profile_end_covmap();) {
+    uint32_t CoverageSize = CovHeader->CoverageSize;
+    uint32_t NR = CovHeader->NRecords;
+    uint32_t FilenamesSize = CovHeader->FilenamesSize;
+    CovHeader =
+        (__llvm_covmap_header *)((char *)CovHeader +
+                                 NR * sizeof(__llvm_covmap_func_record) +
+                                 CoverageSize + FilenamesSize);
+  }
   return rc;
 }
 
 static void writeFileWithoutReturn(void) { __llvm_profile_write_file(); }
 
 COMPILER_RT_VISIBILITY
 int __llvm_profile_register_write_file_atexit(void) {
   static int HasBeenRegistered = 0;
 
   if (HasBeenRegistered)
     return 0;
 
   HasBeenRegistered = 1;
   return atexit(writeFileWithoutReturn);
 }

lib/profile/InstrProfilingPlatformLinux.c

 
 #define PROF_DATA_START INSTR_PROF_SECT_START(INSTR_PROF_DATA_SECT_NAME)
 #define PROF_DATA_STOP INSTR_PROF_SECT_STOP(INSTR_PROF_DATA_SECT_NAME)
 #define PROF_NAME_START INSTR_PROF_SECT_START(INSTR_PROF_NAME_SECT_NAME)
 #define PROF_NAME_STOP INSTR_PROF_SECT_STOP(INSTR_PROF_NAME_SECT_NAME)
 #define PROF_CNTS_START INSTR_PROF_SECT_START(INSTR_PROF_CNTS_SECT_NAME)
 #define PROF_CNTS_STOP INSTR_PROF_SECT_STOP(INSTR_PROF_CNTS_SECT_NAME)
 
+#define COVMAP_START INSTR_PROF_SECT_START(INSTR_PROF_COVMAP_SECT_NAME)
+#define COVMAP_STOP INSTR_PROF_SECT_STOP(INSTR_PROF_COVMAP_SECT_NAME)
+
 /* Declare section start and stop symbols for various sections
  * generated by compiler instrumentation.
  */
 extern __llvm_profile_data PROF_DATA_START COMPILER_RT_VISIBILITY;
 extern __llvm_profile_data PROF_DATA_STOP COMPILER_RT_VISIBILITY;
 extern uint64_t PROF_CNTS_START COMPILER_RT_VISIBILITY;
 extern uint64_t PROF_CNTS_STOP COMPILER_RT_VISIBILITY;
 extern char PROF_NAME_START COMPILER_RT_VISIBILITY;
 extern char PROF_NAME_STOP COMPILER_RT_VISIBILITY;
+extern __llvm_covmap_header COVMAP_START COMPILER_RT_VISIBILITY;
+extern __llvm_covmap_header COVMAP_STOP COMPILER_RT_VISIBILITY;
 
 /* Add dummy data to ensure the section is always created. */
 __llvm_profile_data
     __prof_data_sect_data[0] COMPILER_RT_SECTION(INSTR_PROF_DATA_SECT_NAME_STR);
 uint64_t
     __prof_cnts_sect_data[0] COMPILER_RT_SECTION(INSTR_PROF_CNTS_SECT_NAME_STR);
 char __prof_nms_sect_data[0] COMPILER_RT_SECTION(INSTR_PROF_NAME_SECT_NAME_STR);
 
COMPILER_RT_VISIBILITY const char *__llvm_profile_end_names(void) {
   return &PROF_NAME_STOP;
 }
 COMPILER_RT_VISIBILITY uint64_t *__llvm_profile_begin_counters(void) {
   return &PROF_CNTS_START;
 }
 COMPILER_RT_VISIBILITY uint64_t *__llvm_profile_end_counters(void) {
   return &PROF_CNTS_STOP;
 }
+
+COMPILER_RT_VISIBILITY const __llvm_covmap_header *
+__llvm_profile_begin_covmap(void) {
+  return &COVMAP_START;
+}
+
+COMPILER_RT_VISIBILITY const __llvm_covmap_header *
+__llvm_profile_end_covmap(void) {
+  return &COVMAP_STOP;
+}
+
 #endif