Make __gcov_flush flush counters for all shared libraries

[marco-c]

Summary

This will make the behavior of __gcov_flush match the GCC behavior.

I would like to rename gcov_flush to llvm_gcov_flush (in case of programs linking to libraries built with different compilers), but I guess we can't for compatibility reasons.

[davidxl]

This change will cause each dynamic library to dump modules (gcda files) from other dynamic objects as well -- leading to wrong profile count merged.

lib/profile/GCDAProfiling.c

540

This code looks wrong. I don't see how this can delete all write nodes from this dynamic object.

test/profile/Inputs/instrprof-dlopen-func.c.gcov

7

this is not correct. func is executed only once.

test/profile/Inputs/instrprof-dlopen-func2.c.gcov

7

this is not correct.

[marco-c]

lib/profile/GCDAProfiling.c

540

Aargh, I don't know what I was thinking here, I'll fix it.

test/profile/Inputs/instrprof-dlopen-func.c.gcov

7

I think this is pre-existing behavior unfortunately, I'll test again without the patch.

[marco-c]

I'm using two lists, one for the current dynamic object, one shared between all. We could make the shared one a list of lists, but I feel it would make the code more complex, with no large benefit (if you disagree, I can update the patch).
At writeout, we only write out the current dynamic object counters; at __gcov_flush, we write out and reset counters for all dynamic objects.

A question, why do we need both a writeout function and a flush function? Wouldn't it be OK to just always use flush? When we call writeout, we are atexit, so it doesn't really matter if we clear or not the counters after the writeout, or does it?

[davidxl]

test/profile/Inputs/instrprof-shared-main-gcov-flush-before-shared-call.c

9 ↗

(On Diff #153690)

Make test case more complete:

1. add a non shared call after flush as well

2. test the case when normal exit is not invoked -- in this case, the profile counts accumulated after the flush should not be recorded.

test/profile/Inputs/instrprof-shared-main-gcov-flush-no-writeout.c

9 ↗

(On Diff #153690)

perhaps call 'abort' or '_exit' instead.

test/profile/Inputs/instrprof-shared-main-gcov-flush.c

10

share the same source with the flush-no-writeout case by using a guarding macro: use using exit, and the other uses _exit.

More suggestion on the test case:

Define another function, say 'bar' in the main source file and call it before and after the __gcov_flush() call.

Add another call to 'foo' after the gcov_flush call.

The 'gcov' outputs between the normal write out at exit vs flushed output (when _exit is used) should be different.

(Just noticed that you have a flush-before-call test case -- can consider merge it into one source with macros).

[marco-c]

I've merged all the shared / __gcov_flush tests into a single file and made the test a little more involved by adding a "bar" function in the main file.

[davidxl]

lib/profile/GCDAProfiling.c

116

this loop is still wrong.

Also it is possible to simply the code by removing the if-then-else:

struct fn_node** prev = &list->head;
 while ((*prev) != element) 
      prev = &(*prev)->next;
 (*prev) = element->next;

537

It suffices to do this outside the loop by making current list's head to null.

538

The second one has quadratic behavior.

If the current list is remembered in the fn_node object, you can simply do a one sweep by comparing the recorded list with the current list.

test/profile/Inputs/instrprof-dlopen-func.c.gcov

7

Have you examined why this is wrong? If it is not regression, it is worth fixing as a follow up.

[marco-c]

I've taken another approach which looks simpler to me. Instead of having two lists, I only have a shared list and I use a static variable's address as an identifier for a dynamic object.

I've also added another test (which would have failed with the previous iteration of the patch) which dlopens three libraries.

I will file follow-up bugs for things that don't look right in the llvm-cov output which are not regressions from this patch:

• instrprof-shared-main-gcov-flush_no-writeout.c.gcov: lines 23, 26 and 30 should not be covered; lines 33 and 35 should not be covered (they are considered as uncoverable instead).
• instrprof-dlopen-func{2,3}.c.gcov: the only line in the function should be covered once and not thrice

Regarding removing writeout and only always using __gcov_flush, do you see any disadvantage if we do that?

Regarding llvm_gcov_flush that was recently added, should I remove it since we can now unhide __gcov_flush?

[marco-c]

On Tue, Jul 3, 2018 at 4:29 PM Marco Castelluccio via Phabricator <[e-mail]> wrote:

marco-c updated this revision to Diff 154015.
marco-c added a comment.

I've taken another approach which looks simpler to me. Instead of having two lists, I only have a shared list and I use a static variable's address as an identifier for a dynamic object.

I've also added another test (which would have failed with the previous iteration of the patch) which dlopens three libraries.

I will file follow-up bugs for things that don't look right in the llvm-cov output which are not regressions from this patch:

- instrprof-shared-main-gcov-flush_no-writeout.c.gcov: lines 23, 26 and 30 should not be covered; lines 33 and 35 should not be covered (they are considered as uncoverable instead).
- instrprof-dlopen-func{2,3}.c.gcov: the only line in the function should be covered once and not thrice

Regarding removing writeout and only always using __gcov_flush, do you see any disadvantage if we do that?

writeout function only writes the profile for the current dynamic module which is different from the behavior of __gcov_flush. The form is expected when shared lib is unloaded -- i.e., do not dump other load module's profile unless being explicitly told so (to use gcov_flush). The write out is similar to gcc's gcov_exit. In short, we should keep it as it is.

Sorry, what I meant is that we could remove llvm_gcov_writeout and only keep llvm_gcov_flush (they are defined in lib/Transforms/Instrumentation/GCOVProfiling.cpp and passed to llvm_gcov_init). We currently have writeout functions and flush functions, where the difference is just that the flush function is also resetting the counters to 0.
At exit, instead of calling llvm_gcov_writeout, we could call llvm_gcov_flush. Since we are at exit, the fact that we reset the counters to 0 for the current module doesn't matter (as the module is not usable anymore after that).
At exit we would still call llvm_gcov_flush only for the module that is exiting, at gcov_flush we would call __llvm_gcov_flush for all modules.

Regarding llvm_gcov_flush that was recently added, should I remove it since we can now unhide __gcov_flush?

I suggest we keep it -- there is no harm keeping it. llvm_gcov_flush can be documented to be always non hidden. There might also be a use case that user want to discover the dumper using dlsym, but only want to dump profile for that shared library. In that case, a symbol with protected visibility is needed which is a wrapper to the write-out method.

Should we make llvm_gcov_flush hidden and gcov_flush unhidden then? gcov_flush unhidden would be for compatibility with GCC.

[srhines]

In D48538#1151578, @marco-c wrote:

On Tue, Jul 3, 2018 at 4:29 PM Marco Castelluccio via Phabricator <[e-mail]> wrote:

marco-c updated this revision to Diff 154015.
marco-c added a comment.

I've taken another approach which looks simpler to me. Instead of having two lists, I only have a shared list and I use a static variable's address as an identifier for a dynamic object.

I've also added another test (which would have failed with the previous iteration of the patch) which dlopens three libraries.

I will file follow-up bugs for things that don't look right in the llvm-cov output which are not regressions from this patch:

- instrprof-shared-main-gcov-flush_no-writeout.c.gcov: lines 23, 26 and 30 should not be covered; lines 33 and 35 should not be covered (they are considered as uncoverable instead).
- instrprof-dlopen-func{2,3}.c.gcov: the only line in the function should be covered once and not thrice

Regarding removing writeout and only always using __gcov_flush, do you see any disadvantage if we do that?

writeout function only writes the profile for the current dynamic module which is different from the behavior of __gcov_flush. The form is expected when shared lib is unloaded -- i.e., do not dump other load module's profile unless being explicitly told so (to use gcov_flush). The write out is similar to gcc's gcov_exit. In short, we should keep it as it is.

Sorry, what I meant is that we could remove llvm_gcov_writeout and only keep llvm_gcov_flush (they are defined in lib/Transforms/Instrumentation/GCOVProfiling.cpp and passed to llvm_gcov_init). We currently have writeout functions and flush functions, where the difference is just that the flush function is also resetting the counters to 0.
At exit, instead of calling llvm_gcov_writeout, we could call llvm_gcov_flush. Since we are at exit, the fact that we reset the counters to 0 for the current module doesn't matter (as the module is not usable anymore after that).
At exit we would still call llvm_gcov_flush only for the module that is exiting, at gcov_flush we would call __llvm_gcov_flush for all modules.

Regarding llvm_gcov_flush that was recently added, should I remove it since we can now unhide __gcov_flush?

I suggest we keep it -- there is no harm keeping it. llvm_gcov_flush can be documented to be always non hidden. There might also be a use case that user want to discover the dumper using dlsym, but only want to dump profile for that shared library. In that case, a symbol with protected visibility is needed which is a wrapper to the write-out method.

Should we make llvm_gcov_flush hidden and gcov_flush unhidden then? gcov_flush unhidden would be for compatibility with GCC.

If you are going to hide llvm_gcov_flush(), you might as well delete it and break our implementation that way. We are only going to try to use llvm_gcov_flush() temporarily to restore some missing functionality. When __gcov_flush() becomes available again, we will switch back to it for simplicity.

[davidxl]

LGTM ( watch out any potential breakages)

lib/profile/GCDAProfiling.c

150

this is not needed.

[marco-c]

 Sorry, what I meant is that we could remove __llvm_gcov_writeout and only keep __llvm_gcov_flush (they are defined in lib/Transforms/Instrumentation/GCOVProfiling.cpp and passed to llvm_gcov_init). We currently have writeout functions and flush functions, where the difference is just that the flush function is also resetting the counters to 0.
 At exit, instead of calling __llvm_gcov_writeout, we could call __llvm_gcov_flush. Since we are at exit, the fact that we reset the counters to 0 for the current module doesn't matter (as the module is not usable anymore after that).
At exit we would still call __llvm_gcov_flush only for the module that is exiting, at __gcov_flush we would call __llvm_gcov_flush for all modules.

This sounds safe, but this does not belong to this patch.

Yeah, definitely a separate thing, I'll do it and submit it in another revision.

Looks like Stephane (the only user of the new interface) is ok for you to remove it completely, which is fine by me.

OK, I'll remove it then.

Before landing, I will "stress test" this patch on our CI to make sure everything is still working as before.

[marco-c]

• instrprof-shared-main-gcov-flush_no-writeout.c.gcov: lines 23, 26 and 30 should not be covered; lines 33 and 35 should not be covered (they are considered as uncoverable instead).

I've filed https://bugs.llvm.org/show_bug.cgi?id=38067. It's unrelated to the presence of shared libraries.

• instrprof-dlopen-func{2,3}.c.gcov: the only line in the function should be covered once and not thrice

I've filed https://bugs.llvm.org/show_bug.cgi?id=38065, this one too is unrelated to the presence of shared libraries.

I've also filed https://bugs.llvm.org/show_bug.cgi?id=38066, about wrong line hit counts when exceptions are enabled.

I've tested the patch on our CI and it was working correctly. I'll land it shortly.

[marco-c]

Patch rebased. I've removed llvm_gcov_flush and made __gcov_flush visible.

[uweigand]

It looks like this causes build bot failures on s390x-linux. Three of the new tests fail:
http://lab.llvm.org:8011/builders/clang-s390x-linux/builds/17143

/home/uweigand/sandbox/buildbot/clang-s390x-linux/llvm/projects/compiler-rt/test/profile/Inputs/instrprof-dlopen-dlclose-main.c.gcov:11:15: error: expected string not found in input
// CHECK-NEXT:        1:    6:  dlerror();
              ^
instrprof-dlopen-dlclose-main.c.gcov:11:1: note: scanning from here
4294967296:    6:  dlerror();

This looks suspiciously like an endian problem somewhere, we get 4294967296 == 0x1_0000_0000 instead of 0x0_0000_0001 ...
(s390x is a big-endian machine.)

lib/profile/GCDAProfiling.c

 #define WRITE_BUFFER_SIZE (128 * 1024)
 static char *write_buffer = NULL;
 static uint64_t cur_buffer_size = 0;
 static uint64_t cur_pos = 0;
 static uint64_t file_size = 0;
 static int new_file = 0;
 static int fd = -1;
 
-/*
- * A list of functions to write out the data.
- */
-typedef void (*writeout_fn)();
+typedef void (*fn_ptr)();
+
+struct fn_node {
+  fn_ptr fn;
+  struct fn_node* next;
+};
 
-struct writeout_fn_node {
-  writeout_fn fn;
-  struct writeout_fn_node *next;
+struct fn_list {
+  struct fn_node *head, *tail;
 };
 
-static struct writeout_fn_node *writeout_fn_head = NULL;
-static struct writeout_fn_node *writeout_fn_tail = NULL;
+void fn_list_insert(struct fn_list* list, struct fn_node* element) {
+  if (!list->head) {
+    list->head = list->tail = element;
+  } else {
+    list->tail->next = element;
+    list->tail = element;
+  }
+}
+
+void fn_list_remove(struct fn_list* list, struct fn_node* element) {
+  struct fn_node* prev = NULL;
+
+  if (element == list->head) {
+    list->head = element->next;
+  } else {
+    prev = list->head;
+    while (prev->next != element);
+    prev->next = element->next;
+  }
+
+  if (element == list->tail) {
+    list->tail = prev;
+  }
+}
 
 /*
- *  A list of flush functions that our __gcov_flush() function should call.
+ * A list of functions to write out the data.
  */
-typedef void (*flush_fn)();
+// This is the writeout list specific to a given dynamic object.
+static struct fn_list writeout_fn_list_current;
+// This is the writeout list shared between all dynamic objects.
+struct fn_list writeout_fn_list_shared;
 
-struct flush_fn_node {
-  flush_fn fn;
-  struct flush_fn_node *next;
-};
-
-static struct flush_fn_node *flush_fn_head = NULL;
-static struct flush_fn_node *flush_fn_tail = NULL;
+/*
+ *  A list of flush functions that our __gcov_flush() function should call.
+ */
+// This is the flush list specific to a given dynamic object.
+static struct fn_list flush_fn_list_current;
+// This is the flush list shared between all dynamic objects.
+struct fn_list flush_fn_list_shared;
 
 static void resize_write_buffer(uint64_t size) {
   if (!new_file) return;
   size += cur_pos;
   if (size <= cur_buffer_size) return;
   size = (size - 1) / WRITE_BUFFER_SIZE + 1;
   size *= WRITE_BUFFER_SIZE;
   write_buffer = realloc(write_buffer, size);
   cur_buffer_size = size;
 }
 
 static void write_bytes(const char *s, size_t len) {
   resize_write_buffer(len);
   memcpy(&write_buffer[cur_pos], s, len);
   cur_pos += len;
 }
 
 static void write_32bit_value(uint32_t i) {
   write_bytes((char*)&i, 4);

 #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;
+  static uint32_t run_counted = 0; // We only want to increase the run count once.
   uint32_t val = 0;
   uint64_t save_cur_pos = cur_pos;
 
   if (!output_file) return;
 
   val = read_32bit_value();
 
   if (val != (uint32_t)-1) {
if (val != obj_summary_len) {
       fprintf(stderr, "profiling: %s: cannot merge previous run count: "
                       "mismatched object length (%d)\n",
               filename, val);
       return;
     }
 
     read_32bit_value(); /* checksum, unused */
     read_32bit_value(); /* num, unused */
-    runs += read_32bit_value(); /* Add previous run count to new counter. */
+    uint32_t prev_runs = read_32bit_value();
+    /* Add previous run count to new counter, if not already counted before. */
+    runs = run_counted ? prev_runs : prev_runs + 1;
   }
 
   cur_pos = save_cur_pos;
 
   /* Object summary tag */
   write_bytes("\0\0\0\xa1", 4);
   write_32bit_value(obj_summary_len);
   write_32bit_value(0); /* checksum, unused */
   write_32bit_value(0); /* num, unused */
   write_32bit_value(runs);
   for (i = 3; i < obj_summary_len; ++i)
     write_32bit_value(0);
 
   /* Program summary tag */
   write_bytes("\0\0\0\xa3", 4); /* tag indicates 1 program */
   write_32bit_value(0); /* 0 length */
 
+  run_counted = 1;
+
 #ifdef DEBUG_GCDAPROFILING
   fprintf(stderr, "llvmgcda:   %u runs\n", runs);
 #endif
 }
 
 COMPILER_RT_VISIBILITY
 void llvm_gcda_end_file() {
   /* Write out EOF record. */
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));
+void llvm_register_writeout_function(fn_ptr fn) {
+  struct fn_node* new_node = malloc(sizeof(struct 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;
-  }
+  fn_list_insert(&writeout_fn_list_current, new_node);
+  fn_list_insert(&writeout_fn_list_shared, new_node);
 }
 
 COMPILER_RT_VISIBILITY
 void llvm_writeout_files(void) {
-  struct writeout_fn_node *curr = writeout_fn_head;
+  struct fn_node *curr = writeout_fn_list_current.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;
+  struct fn_node* curr = writeout_fn_list_current.head;
+  while (curr) {
+    fn_list_remove(&writeout_fn_list_current, curr);
+    fn_list_remove(&writeout_fn_list_shared, curr);
+    curr = curr->next;
+    free(curr);
+  }
 }
 
 COMPILER_RT_VISIBILITY
-void llvm_register_flush_function(flush_fn fn) {
-  struct flush_fn_node *new_node = malloc(sizeof(struct flush_fn_node));
+void llvm_register_flush_function(fn_ptr fn) {
+  struct fn_node* new_node = malloc(sizeof(struct 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;
-  }
+  fn_list_insert(&flush_fn_list_current, new_node);
+  fn_list_insert(&flush_fn_list_shared, new_node);
 }
 
 COMPILER_RT_VISIBILITY
 void __gcov_flush() {
-  struct flush_fn_node *curr = flush_fn_head;
+  struct fn_node *curr = flush_fn_list_shared.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);
-  }
+  struct fn_node* curr = flush_fn_list_current.head;
 
-  flush_fn_head = flush_fn_tail = NULL;
+  while (curr) {
+    fn_list_remove(&flush_fn_list_current, curr);
+    fn_list_remove(&flush_fn_list_shared, curr);
+    curr = curr->next;
+    free(curr);
+  }
 }
 
 COMPILER_RT_VISIBILITY
-void llvm_gcov_init(writeout_fn wfn, flush_fn ffn) {
+void llvm_gcov_init(fn_ptr wfn, fn_ptr 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 (*func)(void) = (void (*)(void))dlsym(f1_handle, "func");
+  if (func == NULL) {
+    fprintf(stderr, "unable to lookup symbol 'func': %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;
   }
 
+  void (*func2)(void) = (void (*)(void))dlsym(f2_handle, "func2");
+  if (func2 == NULL) {
+    fprintf(stderr, "unable to lookup symbol 'func2': %s\n", dlerror());
+    return EXIT_FAILURE;
+  }
+  func2();
+
   if (dlclose(f2_handle) != 0) {
     fprintf(stderr, "unable to close 'func2.shared': %s\n", dlerror());
     return EXIT_FAILURE;
   }
 
+  func();
+
+  int g1 = 0;
+  int g2 = 0;
+  int n = 10;
+
+  if (n % 5 == 0)
+    g1++;
+  else
+    g2++;
+
   return EXIT_SUCCESS;
 }
 

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

+// CHECK:        -:    0:Source:{{.*}}Inputs/instrprof-dlopen-dlclose-main.c
+// CHECK-NEXT:        -:    0:Graph:instrprof-dlopen-dlclose-main.gcno
+// CHECK-NEXT:        -:    0:Data:instrprof-dlopen-dlclose-main.gcda
+// CHECK-NEXT:        -:    0:Runs:1
+// CHECK-NEXT:        -:    0:Programs:1
+// CHECK-NEXT:        -:    1:#include <dlfcn.h>
+// CHECK-NEXT:        -:    2:#include <stdio.h>
+// CHECK-NEXT:        -:    3:#include <stdlib.h>
+// CHECK-NEXT:        -:    4:
+// CHECK-NEXT:        -:    5:int main(int argc, char *argv[]) {
+// CHECK-NEXT:        1:    6:  dlerror();
+// CHECK-NEXT:        1:    7:  void *f1_handle = dlopen("func.shared", RTLD_LAZY | RTLD_GLOBAL);
+// CHECK-NEXT:        1:    8:  if (f1_handle == NULL) {
+// CHECK-NEXT:    #####:    9:    fprintf(stderr, "unable to open 'func.shared': %s\n", dlerror());
+// CHECK-NEXT:    #####:   10:    return EXIT_FAILURE;
+// CHECK-NEXT:        -:   11:  }
+// CHECK-NEXT:        -:   12:
+// CHECK-NEXT:        1:   13:  void (*func)(void) = (void (*)(void))dlsym(f1_handle, "func");
+// CHECK-NEXT:        1:   14:  if (func == NULL) {
+// CHECK-NEXT:    #####:   15:    fprintf(stderr, "unable to lookup symbol 'func': %s\n", dlerror());
+// CHECK-NEXT:    #####:   16:    return EXIT_FAILURE;
+// CHECK-NEXT:        -:   17:  }
+// CHECK-NEXT:        -:   18:
+// CHECK-NEXT:        1:   19:  void *f2_handle = dlopen("func2.shared", RTLD_LAZY | RTLD_GLOBAL);
+// CHECK-NEXT:        1:   20:  if (f2_handle == NULL) {
+// CHECK-NEXT:    #####:   21:    fprintf(stderr, "unable to open 'func2.shared': %s\n", dlerror());
+// CHECK-NEXT:    #####:   22:    return EXIT_FAILURE;
+// CHECK-NEXT:        -:   23:  }
+// CHECK-NEXT:        -:   24:
+// CHECK-NEXT:        1:   25:  void (*func2)(void) = (void (*)(void))dlsym(f2_handle, "func2");
+// CHECK-NEXT:        1:   26:  if (func2 == NULL) {
+// CHECK-NEXT:    #####:   27:    fprintf(stderr, "unable to lookup symbol 'func2': %s\n", dlerror());
+// CHECK-NEXT:    #####:   28:    return EXIT_FAILURE;
+// CHECK-NEXT:        -:   29:  }
+// CHECK-NEXT:        1:   30:  func2();
+// CHECK-NEXT:        -:   31:
+// CHECK-NEXT:        1:   32:  if (dlclose(f2_handle) != 0) {
+// CHECK-NEXT:    #####:   33:    fprintf(stderr, "unable to close 'func2.shared': %s\n", dlerror());
+// CHECK-NEXT:    #####:   34:    return EXIT_FAILURE;
+// CHECK-NEXT:        -:   35:  }
+// CHECK-NEXT:        -:   36:
+// CHECK-NEXT:        1:   37:  func();
+// CHECK-NEXT:        -:   38:
+// CHECK-NEXT:        1:   39:  int g1 = 0;
+// CHECK-NEXT:        1:   40:  int g2 = 0;
+// CHECK-NEXT:        1:   41:  int n = 10;
+// CHECK-NEXT:        -:   42:
+// CHECK-NEXT:        1:   43:  if (n % 5 == 0)
+// CHECK-NEXT:        1:   44:    g1++;
+// CHECK-NEXT:        -:   45:  else
+// CHECK-NEXT:    #####:   46:    g2++;
+// CHECK-NEXT:        -:   47:
+// CHECK-NEXT:        1:   48:  return EXIT_SUCCESS;
+// CHECK-NEXT:        1:   49:}
+// CHECK-NEXT:        -:   50:

test/profile/Inputs/instrprof-dlopen-func.c.gcov

+// CHECK:        -:    0:Source:{{.*}}Inputs/instrprof-dlopen-func.c
+// CHECK-NEXT:        -:    0:Graph:instrprof-dlopen-func.gcno
+// CHECK-NEXT:        -:    0:Data:instrprof-dlopen-func.gcda
+// CHECK-NEXT:        -:    0:Runs:1
+// CHECK-NEXT:        -:    0:Programs:1
+// CHECK-NEXT:        3:    1:void func(int K) { if (K) {} }

test/profile/Inputs/instrprof-dlopen-func2.c.gcov

+// CHECK:        -:    0:Source:{{.*}}Inputs/instrprof-dlopen-func2.c
+// CHECK-NEXT:        -:    0:Graph:instrprof-dlopen-func2.gcno
+// CHECK-NEXT:        -:    0:Data:instrprof-dlopen-func2.gcda
+// CHECK-NEXT:        -:    0:Runs:1
+// CHECK-NEXT:        -:    0:Programs:1
+// CHECK-NEXT:        3:    1:void func2(int K) { if (K) {} }

test/profile/Inputs/instrprof-shared-lib.c.gcov

+// CHECK:        -:    0:Source:{{.*}}Inputs/instrprof-shared-lib.c
+// CHECK-NEXT:        -:    0:Graph:instrprof-shared-lib.gcno
+// CHECK-NEXT:        -:    0:Data:instrprof-shared-lib.gcda
+// CHECK-NEXT:        -:    0:Runs:1
+// CHECK-NEXT:        -:    0:Programs:1
+// CHECK-NEXT:        -:    1:int g1 = 0;
+// CHECK-NEXT:        -:    2:int g2 = 1;
+// CHECK-NEXT:        -:    3:
+// CHECK-NEXT:        -:    4:void foo(int n) {
+// CHECK-NEXT:        1:    5:  if (n % 5 == 0)
+// CHECK-NEXT:    #####:    6:    g1++;
+// CHECK-NEXT:        -:    7:  else
+// CHECK-NEXT:        1:    8:    g2++;
+// CHECK-NEXT:        1:    9:}

test/profile/Inputs/instrprof-shared-lib_called-twice.c.gcov

+// CHECK:        -:    0:Source:{{.*}}Inputs/instrprof-shared-lib.c
+// CHECK-NEXT:        -:    0:Graph:instrprof-shared-lib.gcno
+// CHECK-NEXT:        -:    0:Data:instrprof-shared-lib.gcda
+// CHECK-NEXT:        -:    0:Runs:1
+// CHECK-NEXT:        -:    0:Programs:1
+// CHECK-NEXT:        -:    1:int g1 = 0;
+// CHECK-NEXT:        -:    2:int g2 = 1;
+// CHECK-NEXT:        -:    3:
+// CHECK-NEXT:        -:    4:void foo(int n) {
+// CHECK-NEXT:        2:    5:  if (n % 5 == 0)
+// CHECK-NEXT:    #####:    6:    g1++;
+// CHECK-NEXT:        -:    7:  else
+// CHECK-NEXT:        2:    8:    g2++;
+// CHECK-NEXT:        2:    9:}

test/profile/Inputs/instrprof-shared-lib_in-loop.c.gcov

+// CHECK:        -:    0:Source:{{.*}}Inputs/instrprof-shared-lib.c
+// CHECK-NEXT:        -:    0:Graph:instrprof-shared-lib.gcno
+// CHECK-NEXT:        -:    0:Data:instrprof-shared-lib.gcda
+// CHECK-NEXT:        -:    0:Runs:1
+// CHECK-NEXT:        -:    0:Programs:1
+// CHECK-NEXT:        -:    1:int g1 = 0;
+// CHECK-NEXT:        -:    2:int g2 = 1;
+// CHECK-NEXT:        -:    3:
+// CHECK-NEXT:        -:    4:void foo(int n) {
+// CHECK-NEXT:  1000000:    5:  if (n % 5 == 0)
+// CHECK-NEXT:   360000:    6:    g1++;
+// CHECK-NEXT:        -:    7:  else
+// CHECK-NEXT:   640000:    8:    g2++;
+// CHECK-NEXT:  1000000:    9:}

test/profile/Inputs/instrprof-shared-main-gcov-flush.c

+extern void foo(int n);
+extern void __gcov_flush(void);
+
+int bar1 = 0;
+int bar2 = 1;
+
+void bar(int n) {
+  if (n % 5 == 0)
+    bar1++;
+  else
+    bar2++;
+}
+
+int main(int argc, char *argv[]) {
+#ifdef SHARED_CALL_BEFORE_GCOV_FLUSH
+  foo(1);
+#endif
+
+  bar(5);
+
+  __gcov_flush();
+
+  bar(5);
+
+#ifdef SHARED_CALL_AFTER_GCOV_FLUSH
+  foo(1);
+#endif
+
+#ifdef EXIT_ABRUPTLY
+  _exit(0);
+#endif
+
+  bar(5);
+
+  return 0;
+}

test/profile/Inputs/instrprof-shared-main-gcov-flush_no-writeout.c.gcov

+// CHECK:        -:    0:Source:{{.*}}Inputs/instrprof-shared-main-gcov-flush.c
+// CHECK-NEXT:        -:    0:Graph:instrprof-shared-main-gcov-flush.gcno
+// CHECK-NEXT:        -:    0:Data:instrprof-shared-main-gcov-flush.gcda
+// CHECK-NEXT:        -:    0:Runs:1
+// CHECK-NEXT:        -:    0:Programs:1
+// CHECK-NEXT:        -:    1:extern void foo(int n);
+// CHECK-NEXT:        -:    2:extern void __gcov_flush(void);
+// CHECK-NEXT:        -:    3:
+// CHECK-NEXT:        -:    4:int bar1 = 0;
+// CHECK-NEXT:        -:    5:int bar2 = 1;
+// CHECK-NEXT:        -:    6:
+// CHECK-NEXT:        -:    7:void bar(int n) {
+// CHECK-NEXT:        1:    8:  if (n % 5 == 0)
+// CHECK-NEXT:        1:    9:    bar1++;
+// CHECK-NEXT:        -:   10:  else
+// CHECK-NEXT:    #####:   11:    bar2++;
+// CHECK-NEXT:        1:   12:}
+// CHECK-NEXT:        -:   13:
+// CHECK-NEXT:        -:   14:int main(int argc, char *argv[]) {
+// CHECK-NEXT:        -:   15:#ifdef SHARED_CALL_BEFORE_GCOV_FLUSH
+// CHECK-NEXT:        1:   16:  foo(1);
+// CHECK-NEXT:        -:   17:#endif
+// CHECK-NEXT:        -:   18:
+// CHECK-NEXT:        1:   19:  bar(5);
+// CHECK-NEXT:        -:   20:
+// CHECK-NEXT:        1:   21:  __gcov_flush();
+// CHECK-NEXT:        -:   22:
+// CHECK-NEXT:        1:   23:  bar(5);
+// CHECK-NEXT:        -:   24:
+// CHECK-NEXT:        -:   25:#ifdef SHARED_CALL_AFTER_GCOV_FLUSH
+// CHECK-NEXT:        1:   26:  foo(1);
+// CHECK-NEXT:        -:   27:#endif
+// CHECK-NEXT:        -:   28:
+// CHECK-NEXT:        -:   29:#ifdef EXIT_ABRUPTLY
+// CHECK-NEXT:        1:   30:  _exit(0);
+// CHECK-NEXT:        -:   31:#endif
+// CHECK-NEXT:        -:   32:
+// CHECK-NEXT:        -:   33:  bar(5);
+// CHECK-NEXT:        -:   34:
+// CHECK-NEXT:        -:   35:  return 0;
+// CHECK-NEXT:    #####:   36:}

test/profile/Inputs/instrprof-shared-main-gcov-flush_shared-call-after.c.gcov

+// CHECK:        -:    0:Source:{{.*}}Inputs/instrprof-shared-main-gcov-flush.c
+// CHECK-NEXT:        -:    0:Graph:instrprof-shared-main-gcov-flush.gcno
+// CHECK-NEXT:        -:    0:Data:instrprof-shared-main-gcov-flush.gcda
+// CHECK-NEXT:        -:    0:Runs:1
+// CHECK-NEXT:        -:    0:Programs:1
+// CHECK-NEXT:        -:    1:extern void foo(int n);
+// CHECK-NEXT:        -:    2:extern void __gcov_flush(void);
+// CHECK-NEXT:        -:    3:
+// CHECK-NEXT:        -:    4:int bar1 = 0;
+// CHECK-NEXT:        -:    5:int bar2 = 1;
+// CHECK-NEXT:        -:    6:
+// CHECK-NEXT:        -:    7:void bar(int n) {
+// CHECK-NEXT:        3:    8:  if (n % 5 == 0)
+// CHECK-NEXT:        3:    9:    bar1++;
+// CHECK-NEXT:        -:   10:  else
+// CHECK-NEXT:    #####:   11:    bar2++;
+// CHECK-NEXT:        3:   12:}
+// CHECK-NEXT:        -:   13:
+// CHECK-NEXT:        -:   14:int main(int argc, char *argv[]) {
+// CHECK-NEXT:        -:   15:#ifdef SHARED_CALL_BEFORE_GCOV_FLUSH
+// CHECK-NEXT:        -:   16:  foo(1);
+// CHECK-NEXT:        -:   17:#endif
+// CHECK-NEXT:        -:   18:
+// CHECK-NEXT:        1:   19:  bar(5);
+// CHECK-NEXT:        -:   20:
+// CHECK-NEXT:        1:   21:  __gcov_flush();
+// CHECK-NEXT:        -:   22:
+// CHECK-NEXT:        1:   23:  bar(5);
+// CHECK-NEXT:        -:   24:
+// CHECK-NEXT:        -:   25:#ifdef SHARED_CALL_AFTER_GCOV_FLUSH
+// CHECK-NEXT:        1:   26:  foo(1);
+// CHECK-NEXT:        -:   27:#endif
+// CHECK-NEXT:        -:   28:
+// CHECK-NEXT:        -:   29:#ifdef EXIT_ABRUPTLY
+// CHECK-NEXT:        -:   30:  _exit(0);
+// CHECK-NEXT:        -:   31:#endif
+// CHECK-NEXT:        -:   32:
+// CHECK-NEXT:        1:   33:  bar(5);
+// CHECK-NEXT:        -:   34:
+// CHECK-NEXT:        1:   35:  return 0;
+// CHECK-NEXT:        -:   36:}

test/profile/Inputs/instrprof-shared-main-gcov-flush_shared-call-before-after.c.gcov

+// CHECK:        -:    0:Source:{{.*}}Inputs/instrprof-shared-main-gcov-flush.c
+// CHECK-NEXT:        -:    0:Graph:instrprof-shared-main-gcov-flush.gcno
+// CHECK-NEXT:        -:    0:Data:instrprof-shared-main-gcov-flush.gcda
+// CHECK-NEXT:        -:    0:Runs:1
+// CHECK-NEXT:        -:    0:Programs:1
+// CHECK-NEXT:        -:    1:extern void foo(int n);
+// CHECK-NEXT:        -:    2:extern void __gcov_flush(void);
+// CHECK-NEXT:        -:    3:
+// CHECK-NEXT:        -:    4:int bar1 = 0;
+// CHECK-NEXT:        -:    5:int bar2 = 1;
+// CHECK-NEXT:        -:    6:
+// CHECK-NEXT:        -:    7:void bar(int n) {
+// CHECK-NEXT:        3:    8:  if (n % 5 == 0)
+// CHECK-NEXT:        3:    9:    bar1++;
+// CHECK-NEXT:        -:   10:  else
+// CHECK-NEXT:    #####:   11:    bar2++;
+// CHECK-NEXT:        3:   12:}
+// CHECK-NEXT:        -:   13:
+// CHECK-NEXT:        -:   14:int main(int argc, char *argv[]) {
+// CHECK-NEXT:        -:   15:#ifdef SHARED_CALL_BEFORE_GCOV_FLUSH
+// CHECK-NEXT:        1:   16:  foo(1);
+// CHECK-NEXT:        -:   17:#endif
+// CHECK-NEXT:        -:   18:
+// CHECK-NEXT:        1:   19:  bar(5);
+// CHECK-NEXT:        -:   20:
+// CHECK-NEXT:        1:   21:  __gcov_flush();
+// CHECK-NEXT:        -:   22:
+// CHECK-NEXT:        1:   23:  bar(5);
+// CHECK-NEXT:        -:   24:
+// CHECK-NEXT:        -:   25:#ifdef SHARED_CALL_AFTER_GCOV_FLUSH
+// CHECK-NEXT:        1:   26:  foo(1);
+// CHECK-NEXT:        -:   27:#endif
+// CHECK-NEXT:        -:   28:
+// CHECK-NEXT:        -:   29:#ifdef EXIT_ABRUPTLY
+// CHECK-NEXT:        -:   30:  _exit(0);
+// CHECK-NEXT:        -:   31:#endif
+// CHECK-NEXT:        -:   32:
+// CHECK-NEXT:        1:   33:  bar(5);
+// CHECK-NEXT:        -:   34:
+// CHECK-NEXT:        1:   35:  return 0;
+// CHECK-NEXT:        -:   36:}

test/profile/Inputs/instrprof-shared-main-gcov-flush_shared-call-before.c.gcov

+// CHECK:        -:    0:Source:{{.*}}Inputs/instrprof-shared-main-gcov-flush.c
+// CHECK-NEXT:        -:    0:Graph:instrprof-shared-main-gcov-flush.gcno
+// CHECK-NEXT:        -:    0:Data:instrprof-shared-main-gcov-flush.gcda
+// CHECK-NEXT:        -:    0:Runs:1
+// CHECK-NEXT:        -:    0:Programs:1
+// CHECK-NEXT:        -:    1:extern void foo(int n);
+// CHECK-NEXT:        -:    2:extern void __gcov_flush(void);
+// CHECK-NEXT:        -:    3:
+// CHECK-NEXT:        -:    4:int bar1 = 0;
+// CHECK-NEXT:        -:    5:int bar2 = 1;
+// CHECK-NEXT:        -:    6:
+// CHECK-NEXT:        -:    7:void bar(int n) {
+// CHECK-NEXT:        3:    8:  if (n % 5 == 0)
+// CHECK-NEXT:        3:    9:    bar1++;
+// CHECK-NEXT:        -:   10:  else
+// CHECK-NEXT:    #####:   11:    bar2++;
+// CHECK-NEXT:        3:   12:}
+// CHECK-NEXT:        -:   13:
+// CHECK-NEXT:        -:   14:int main(int argc, char *argv[]) {
+// CHECK-NEXT:        -:   15:#ifdef SHARED_CALL_BEFORE_GCOV_FLUSH
+// CHECK-NEXT:        1:   16:  foo(1);
+// CHECK-NEXT:        -:   17:#endif
+// CHECK-NEXT:        -:   18:
+// CHECK-NEXT:        1:   19:  bar(5);
+// CHECK-NEXT:        -:   20:
+// CHECK-NEXT:        1:   21:  __gcov_flush();
+// CHECK-NEXT:        -:   22:
+// CHECK-NEXT:        1:   23:  bar(5);
+// CHECK-NEXT:        -:   24:
+// CHECK-NEXT:        -:   25:#ifdef SHARED_CALL_AFTER_GCOV_FLUSH
+// CHECK-NEXT:        -:   26:  foo(1);
+// CHECK-NEXT:        -:   27:#endif
+// CHECK-NEXT:        -:   28:
+// CHECK-NEXT:        -:   29:#ifdef EXIT_ABRUPTLY
+// CHECK-NEXT:        -:   30:  _exit(0);
+// CHECK-NEXT:        -:   31:#endif
+// CHECK-NEXT:        -:   32:
+// CHECK-NEXT:        1:   33:  bar(5);
+// CHECK-NEXT:        -:   34:
+// CHECK-NEXT:        1:   35:  return 0;
+// CHECK-NEXT:        -:   36:}

test/profile/Inputs/instrprof-shared-main.c.gcov

+// CHECK:        -:    0:Source:{{.*}}Inputs/instrprof-shared-main.c
+// CHECK-NEXT:        -:    0:Graph:instrprof-shared-main.gcno
+// CHECK-NEXT:        -:    0:Data:instrprof-shared-main.gcda
+// CHECK-NEXT:        -:    0:Runs:1
+// CHECK-NEXT:        -:    0:Programs:1
+// CHECK-NEXT:        -:    1:extern int g1, g2;
+// CHECK-NEXT:        -:    2:extern void foo(int n);
+// CHECK-NEXT:        -:    3:
+// CHECK-NEXT:        -:    4:int main() {
+// CHECK-NEXT:        -:    5:  int i, j;
+// CHECK-NEXT:     2002:    6:  for (i = 0; i < 1000; i++)
+// CHECK-NEXT:  2002000:    7:    for (j = 0; j < 1000; j++)
+// CHECK-NEXT:  1001000:    8:      foo(i * j);
+// CHECK-NEXT:        -:    9:
+// CHECK-NEXT:        1:   10:  if (g2 - g1 == 280001)
+// CHECK-NEXT:        1:   11:    return 0;
+// CHECK-NEXT:    #####:   12:  return 1;
+// CHECK-NEXT:        1:   13:}

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: cd %t.d
+
+RUN: %clang --coverage -o func.shared -fPIC -shared %S/Inputs/instrprof-dlopen-func.c
+RUN: %clang --coverage -o 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
+RUN: llvm-cov gcov instrprof-dlopen-dlclose-main.gcda
+RUN: FileCheck --match-full-lines --strict-whitespace --input-file instrprof-dlopen-dlclose-main.c.gcov %S/Inputs/instrprof-dlopen-dlclose-main.c.gcov
+RUN: llvm-cov gcov instrprof-dlopen-func.gcda
+RUN: FileCheck --match-full-lines --strict-whitespace --input-file instrprof-dlopen-func.c.gcov %S/Inputs/instrprof-dlopen-func.c.gcov
+RUN: llvm-cov gcov instrprof-dlopen-func2.gcda
+RUN: FileCheck --match-full-lines --strict-whitespace --input-file instrprof-dlopen-func2.c.gcov %S/Inputs/instrprof-dlopen-func2.c.gcov
+RUN: rm instrprof-dlopen-dlclose-main.gcda instrprof-dlopen-func.gcda instrprof-dlopen-func2.gcda

test/profile/instrprof-gcov-two-objects.test

+RUN: mkdir -p %t.d
+RUN: cd %t.d
+
+RUN: %clang --coverage -o instrprof-shared-lib.o -c %S/Inputs/instrprof-shared-lib.c
+RUN: test -f instrprof-shared-lib.gcno
+
+RUN: %clang --coverage -o instrprof-shared-main.o -c %S/Inputs/instrprof-shared-main.c
+RUN: test -f instrprof-shared-main.gcno
+
+RUN: %clang --coverage -o %t instrprof-shared-main.o instrprof-shared-lib.o
+RUN: test -f %t
+
+RUN: %run %t
+RUN: llvm-cov gcov instrprof-shared-main.gcda
+RUN: FileCheck --match-full-lines --strict-whitespace --input-file instrprof-shared-main.c.gcov %S/Inputs/instrprof-shared-main.c.gcov
+RUN: llvm-cov gcov instrprof-shared-lib.gcda
+RUN: FileCheck --match-full-lines --strict-whitespace --input-file instrprof-shared-lib.c.gcov %S/Inputs/instrprof-shared-lib_in-loop.c.gcov
+RUN: rm instrprof-shared-main.gcda instrprof-shared-lib.gcda

test/profile/instrprof-shared-gcov-flush.test

+RUN: mkdir -p %t.d
+RUN: cd %t.d
+
+RUN: %clang --coverage -o libfunc.so -fPIC -shared %S/Inputs/instrprof-shared-lib.c
+RUN: test -f instrprof-shared-lib.gcno
+
+# Test the case where we exit abruptly after calling __gcov_flush, which means we don't write out the counters at exit.
+RUN: %clang -DEXIT_ABRUPTLY -DSHARED_CALL_BEFORE_GCOV_FLUSH -DSHARED_CALL_AFTER_GCOV_FLUSH --coverage -o %t -L%t.d -rpath %t.d -lfunc %S/Inputs/instrprof-shared-main-gcov-flush.c
+RUN: test -f instrprof-shared-main-gcov-flush.gcno
+
+RUN: %run %t
+RUN: llvm-cov gcov instrprof-shared-main-gcov-flush.gcda
+RUN: FileCheck --match-full-lines --strict-whitespace --input-file instrprof-shared-main-gcov-flush.c.gcov %S/Inputs/instrprof-shared-main-gcov-flush_no-writeout.c.gcov
+RUN: llvm-cov gcov instrprof-shared-lib.gcda
+RUN: FileCheck --match-full-lines --strict-whitespace --input-file instrprof-shared-lib.c.gcov %S/Inputs/instrprof-shared-lib.c.gcov
+RUN: rm instrprof-shared-main-gcov-flush.gcda instrprof-shared-lib.gcda
+
+# Test the case where we exit normally and we have a call to the shared library function before __gcov_flush.
+RUN: %clang -DSHARED_CALL_BEFORE_GCOV_FLUSH --coverage -o %t -L%t.d -rpath %t.d -lfunc %S/Inputs/instrprof-shared-main-gcov-flush.c
+RUN: test -f instrprof-shared-main-gcov-flush.gcno
+
+RUN: %run %t
+RUN: llvm-cov gcov instrprof-shared-main-gcov-flush.gcda
+RUN: FileCheck --match-full-lines --strict-whitespace --input-file instrprof-shared-main-gcov-flush.c.gcov %S/Inputs/instrprof-shared-main-gcov-flush_shared-call-before.c.gcov
+RUN: llvm-cov gcov instrprof-shared-lib.gcda
+RUN: FileCheck --match-full-lines --strict-whitespace --input-file instrprof-shared-lib.c.gcov %S/Inputs/instrprof-shared-lib.c.gcov
+RUN: rm instrprof-shared-main-gcov-flush.gcda instrprof-shared-lib.gcda
+
+# Test the case where we exit normally and we have a call to the shared library function after __gcov_flush.
+RUN: %clang -DSHARED_CALL_AFTER_GCOV_FLUSH --coverage -o %t -L%t.d -rpath %t.d -lfunc %S/Inputs/instrprof-shared-main-gcov-flush.c
+RUN: test -f instrprof-shared-main-gcov-flush.gcno
+
+RUN: %run %t
+RUN: llvm-cov gcov instrprof-shared-main-gcov-flush.gcda
+RUN: FileCheck --match-full-lines --strict-whitespace --input-file instrprof-shared-main-gcov-flush.c.gcov %S/Inputs/instrprof-shared-main-gcov-flush_shared-call-after.c.gcov
+RUN: llvm-cov gcov instrprof-shared-lib.gcda
+RUN: FileCheck --match-full-lines --strict-whitespace --input-file instrprof-shared-lib.c.gcov %S/Inputs/instrprof-shared-lib.c.gcov
+RUN: rm instrprof-shared-main-gcov-flush.gcda instrprof-shared-lib.gcda
+
+# Test the case where we exit normally and we have calls to the shared library function before and after __gcov_flush.
+RUN: %clang -DSHARED_CALL_BEFORE_GCOV_FLUSH -DSHARED_CALL_AFTER_GCOV_FLUSH --coverage -o %t -L%t.d -rpath %t.d -lfunc %S/Inputs/instrprof-shared-main-gcov-flush.c
+RUN: test -f instrprof-shared-main-gcov-flush.gcno
+
+RUN: %run %t
+RUN: llvm-cov gcov instrprof-shared-main-gcov-flush.gcda
+RUN: FileCheck --match-full-lines --strict-whitespace --input-file instrprof-shared-main-gcov-flush.c.gcov %S/Inputs/instrprof-shared-main-gcov-flush_shared-call-before-after.c.gcov
+RUN: llvm-cov gcov instrprof-shared-lib.gcda
+RUN: FileCheck --match-full-lines --strict-whitespace --input-file instrprof-shared-lib.c.gcov %S/Inputs/instrprof-shared-lib_called-twice.c.gcov
+RUN: rm instrprof-shared-main-gcov-flush.gcda instrprof-shared-lib.gcda