Hide some symbols to avoid a crash on shutdown when using code coverage

[sylvestre.ledru]

Summary

gcov / gcda-based profiling crashes when shared libraries are unloaded

Patch by Benoit Belley and test by Marco Castelluccio for Firefox

See https://bugs.llvm.org/show_bug.cgi?id=27224 & https://bugzilla.mozilla.org/show_bug.cgi?id=1401230

[davidxl]

Can you add a test case with shared libraries?

[belleyb]

Autodesk would also like to see this fix merged into LLVM 5.0.1 and we also agree about the importance of having a regression tests.

@sylvestre.ledru : Is someone on the Firefox team working on writing a unit test for this ? Shall we jump-in and try to help ?

[belleyb]

@sylvestre.ledru Thanks for the test!

[sylvestre.ledru]

please thank Marco :)

[sylvestre.ledru]

@davidxl David, is that ok with you? Can you sign off this change? Thanks

[sylvestre.ledru]

I added two more reviewers as we would like to get that in trunk before 6.0 branches.

[marco-c]

The change was already positively reviewed with the request for a test, which has been written since then.

lib/profile/GCDAProfiling.c

 /*
  * --- LLVM line counter API ---
  */
 
 /* A file in this case is a translation unit. Each .o file built with line
  * profiling enabled will emit to a different file. Only one file may be
  * started at a time.
  */
+COMPILER_RT_VISIBILITY
 void llvm_gcda_start_file(const char *orig_filename, const char version[4],
                           uint32_t checksum) {
   const char *mode = "r+b";
   filename = mangle_filename(orig_filename);
 
   /* Try just opening the file. */
   new_file = 0;
   fd = open(filename, O_RDWR | O_BINARY);

 #ifdef DEBUG_GCDAPROFILING
   fprintf(stderr, "llvmgcda: [%s]\n", orig_filename);
 #endif
 }
 
 /* Given an array of pointers to counters (counters), increment the n-th one,
  * where we're also given a pointer to n (predecessor).
  */
+COMPILER_RT_VISIBILITY
 void llvm_gcda_increment_indirect_counter(uint32_t *predecessor,
                                           uint64_t **counters) {
   uint64_t *counter;
   uint32_t pred;
 
   pred = *predecessor;
   if (pred == 0xffffffff)
     return;
   counter = counters[pred];
 
   /* Don't crash if the pred# is out of sync. This can happen due to threads,
      or because of a TODO in GCOVProfiling.cpp buildEdgeLookupTable(). */
   if (counter)
     ++*counter;
 #ifdef DEBUG_GCDAPROFILING
   else
     fprintf(stderr,
             "llvmgcda: increment_indirect_counter counters=%08llx, pred=%u\n",
             *counter, *predecessor);
 #endif
 }
 
+COMPILER_RT_VISIBILITY
 void llvm_gcda_emit_function(uint32_t ident, const char *function_name,
                              uint32_t func_checksum, uint8_t use_extra_checksum,
                              uint32_t cfg_checksum) {
   uint32_t len = 2;
 
   if (use_extra_checksum)
     len++;
 #ifdef DEBUG_GCDAPROFILING
#endif
   write_32bit_value(ident);
   write_32bit_value(func_checksum);
   if (use_extra_checksum)
     write_32bit_value(cfg_checksum);
   if (function_name)
     write_string(function_name);
 }
 
+COMPILER_RT_VISIBILITY
 void llvm_gcda_emit_arcs(uint32_t num_counters, uint64_t *counters) {
   uint32_t i;
   uint64_t *old_ctrs = NULL;
   uint32_t val = 0;
   uint64_t save_cur_pos = cur_pos;
 
   if (!output_file) return;
 

 
 #ifdef DEBUG_GCDAPROFILING
   fprintf(stderr, "llvmgcda:   %u arcs\n", num_counters);
   for (i = 0; i < num_counters; ++i)
     fprintf(stderr, "llvmgcda:   %llu\n", (unsigned long long)counters[i]);
 #endif
 }
 
+COMPILER_RT_VISIBILITY
 void llvm_gcda_summary_info() {
   const uint32_t obj_summary_len = 9; /* Length for gcov compatibility. */
   uint32_t i;
   uint32_t runs = 1;
   uint32_t val = 0;
   uint64_t save_cur_pos = cur_pos;
 
   if (!output_file) return;
void llvm_gcda_summary_info() {
   write_bytes("\0\0\0\xa3", 4); /* tag indicates 1 program */
   write_32bit_value(0); /* 0 length */
 
 #ifdef DEBUG_GCDAPROFILING
   fprintf(stderr, "llvmgcda:   %u runs\n", runs);
 #endif
 }
 
+COMPILER_RT_VISIBILITY
 void llvm_gcda_end_file() {
   /* Write out EOF record. */
   if (output_file) {
     write_bytes("\0\0\0\0\0\0\0\0", 8);
 
     if (new_file) {
       fwrite(write_buffer, cur_pos, 1, output_file);
       free(write_buffer);
void llvm_gcda_end_file() {
   }
   free(filename);
 
 #ifdef DEBUG_GCDAPROFILING
   fprintf(stderr, "llvmgcda: -----\n");
 #endif
 }
 
+COMPILER_RT_VISIBILITY
 void llvm_register_writeout_function(writeout_fn fn) {
   struct writeout_fn_node *new_node = malloc(sizeof(struct writeout_fn_node));
   new_node->fn = fn;
   new_node->next = NULL;
 
   if (!writeout_fn_head) {
     writeout_fn_head = writeout_fn_tail = new_node;
   } else {
     writeout_fn_tail->next = new_node;
     writeout_fn_tail = new_node;
   }
 }
 
+COMPILER_RT_VISIBILITY
 void llvm_writeout_files(void) {
   struct writeout_fn_node *curr = writeout_fn_head;
 
   while (curr) {
     curr->fn();
     curr = curr->next;
   }
 }
 
+COMPILER_RT_VISIBILITY
 void llvm_delete_writeout_function_list(void) {
   while (writeout_fn_head) {
     struct writeout_fn_node *node = writeout_fn_head;
     writeout_fn_head = writeout_fn_head->next;
     free(node);
   }
   
   writeout_fn_head = writeout_fn_tail = NULL;
 }
 
+COMPILER_RT_VISIBILITY
 void llvm_register_flush_function(flush_fn fn) {
   struct flush_fn_node *new_node = malloc(sizeof(struct flush_fn_node));
   new_node->fn = fn;
   new_node->next = NULL;
 
   if (!flush_fn_head) {
     flush_fn_head = flush_fn_tail = new_node;
   } else {
     flush_fn_tail->next = new_node;
     flush_fn_tail = new_node;
   }
 }
 
+COMPILER_RT_VISIBILITY
 void __gcov_flush() {
   struct flush_fn_node *curr = flush_fn_head;
 
   while (curr) {
     curr->fn();
     curr = curr->next;
   }
 }
 
+COMPILER_RT_VISIBILITY
 void llvm_delete_flush_function_list(void) {
   while (flush_fn_head) {
     struct flush_fn_node *node = flush_fn_head;
     flush_fn_head = flush_fn_head->next;
     free(node);
   }
 
   flush_fn_head = flush_fn_tail = NULL;
 }
 
+COMPILER_RT_VISIBILITY
 void llvm_gcov_init(writeout_fn wfn, flush_fn ffn) {
   static int atexit_ran = 0;
 
   if (wfn)
     llvm_register_writeout_function(wfn);
 
   if (ffn)
     llvm_register_flush_function(ffn);

test/profile/Inputs/instrprof-dlopen-dlclose-main.c

+#include <dlfcn.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+int main(int argc, char *argv[]) {
+  dlerror();
+  void *f1_handle = dlopen("func.shared", RTLD_LAZY | RTLD_GLOBAL);
+  if (f1_handle == NULL) {
+    fprintf(stderr, "unable to open 'func.shared': %s\n", dlerror());
+    return EXIT_FAILURE;
+  }
+
+  void *f2_handle = dlopen("func2.shared", RTLD_LAZY | RTLD_GLOBAL);
+  if (f2_handle == NULL) {
+    fprintf(stderr, "unable to open 'func2.shared': %s\n", dlerror());
+    return EXIT_FAILURE;
+  }
+
+  if (dlclose(f2_handle) != 0) {
+    fprintf(stderr, "unable to close 'func2.shared': %s\n", dlerror());
+    return EXIT_FAILURE;
+  }
+
+  return EXIT_SUCCESS;
+}
+

test/profile/instrprof-dlopen-dlclose-gcov.test

+RUN: mkdir -p %t.d
+RUN: %clang --coverage -o %t.d/func.shared -fPIC -shared %S/Inputs/instrprof-dlopen-func.c
+RUN: %clang --coverage -o %t.d/func2.shared -fPIC -shared %S/Inputs/instrprof-dlopen-func2.c
+RUN: %clang --coverage -o %t -fPIC -rpath %t.d %S/Inputs/instrprof-dlopen-dlclose-main.c
+
+RUN: %run %t