| /*===- GCDAProfiling.c - Support library for GCDA file emission -----------===*\ |
| |* |
| |* Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| |* See https://llvm.org/LICENSE.txt for license information. |
| |* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| |* |
| |*===----------------------------------------------------------------------===*| |
| |* |
| |* This file implements the call back routines for the gcov profiling |
| |* instrumentation pass. Link against this library when running code through |
| |* the -insert-gcov-profiling LLVM pass. |
| |* |
| |* We emit files in a corrupt version of GCOV's "gcda" file format. These files |
| |* are only close enough that LCOV will happily parse them. Anything that lcov |
| |* ignores is missing. |
| |* |
| |* TODO: gcov is multi-process safe by having each exit open the existing file |
| |* and append to it. We'd like to achieve that and be thread-safe too. |
| |* |
| \*===----------------------------------------------------------------------===*/ |
| |
| #if !defined(__Fuchsia__) |
| |
| #include <errno.h> |
| #include <fcntl.h> |
| #include <stdint.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| |
| #if defined(_WIN32) |
| #define WIN32_LEAN_AND_MEAN |
| #include <windows.h> |
| #include "WindowsMMap.h" |
| #else |
| #include <sys/file.h> |
| #include <sys/mman.h> |
| #include <sys/types.h> |
| #include <unistd.h> |
| #endif |
| |
| #include "InstrProfiling.h" |
| #include "InstrProfilingUtil.h" |
| |
| /* #define DEBUG_GCDAPROFILING */ |
| |
| enum { |
| GCOV_DATA_MAGIC = 0x67636461, // "gcda" |
| |
| GCOV_TAG_FUNCTION = 0x01000000, |
| GCOV_TAG_COUNTER_ARCS = 0x01a10000, |
| // GCOV_TAG_OBJECT_SUMMARY superseded GCOV_TAG_PROGRAM_SUMMARY in GCC 9. |
| GCOV_TAG_OBJECT_SUMMARY = 0xa1000000, |
| GCOV_TAG_PROGRAM_SUMMARY = 0xa3000000, |
| }; |
| |
| /* |
| * --- GCOV file format I/O primitives --- |
| */ |
| |
| /* |
| * The current file name we're outputting. Used primarily for error logging. |
| */ |
| static char *filename = NULL; |
| |
| /* |
| * The current file we're outputting. |
| */ |
| static FILE *output_file = NULL; |
| |
| /* |
| * Buffer that we write things into. |
| */ |
| #define WRITE_BUFFER_SIZE (128 * 1024) |
| static unsigned 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 gcov_version; |
| #if defined(_WIN32) |
| static HANDLE mmap_handle = NULL; |
| #endif |
| static int fd = -1; |
| |
| typedef void (*fn_ptr)(void); |
| |
| typedef void* dynamic_object_id; |
| // The address of this variable identifies a given dynamic object. |
| static dynamic_object_id current_id; |
| #define CURRENT_ID (¤t_id) |
| |
| struct fn_node { |
| dynamic_object_id id; |
| fn_ptr fn; |
| struct fn_node* next; |
| }; |
| |
| struct fn_list { |
| struct fn_node *head, *tail; |
| }; |
| |
| /* |
| * A list of functions to write out the data, shared between all dynamic objects. |
| */ |
| struct fn_list writeout_fn_list; |
| |
| /* |
| * A list of reset functions, shared between all dynamic objects. |
| */ |
| struct fn_list reset_fn_list; |
| |
| static void fn_list_insert(struct fn_list* list, fn_ptr fn) { |
| struct fn_node* new_node = malloc(sizeof(struct fn_node)); |
| new_node->fn = fn; |
| new_node->next = NULL; |
| new_node->id = CURRENT_ID; |
| |
| if (!list->head) { |
| list->head = list->tail = new_node; |
| } else { |
| list->tail->next = new_node; |
| list->tail = new_node; |
| } |
| } |
| |
| static void fn_list_remove(struct fn_list* list) { |
| struct fn_node* curr = list->head; |
| struct fn_node* prev = NULL; |
| struct fn_node* next = NULL; |
| |
| while (curr) { |
| next = curr->next; |
| |
| if (curr->id == CURRENT_ID) { |
| if (curr == list->head) { |
| list->head = next; |
| } |
| |
| if (curr == list->tail) { |
| list->tail = prev; |
| } |
| |
| if (prev) { |
| prev->next = next; |
| } |
| |
| free(curr); |
| } else { |
| prev = curr; |
| } |
| |
| curr = next; |
| } |
| } |
| |
| 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); |
| } |
| |
| static void write_64bit_value(uint64_t i) { |
| // GCOV uses a lo-/hi-word format even on big-endian systems. |
| // See also GCOVBuffer::readInt64 in LLVM. |
| uint32_t lo = (uint32_t) i; |
| uint32_t hi = (uint32_t) (i >> 32); |
| write_32bit_value(lo); |
| write_32bit_value(hi); |
| } |
| |
| static uint32_t read_32bit_value(void) { |
| uint32_t val; |
| |
| if (new_file) |
| return (uint32_t)-1; |
| |
| val = *(uint32_t*)&write_buffer[cur_pos]; |
| cur_pos += 4; |
| return val; |
| } |
| |
| static uint64_t read_64bit_value(void) { |
| // GCOV uses a lo-/hi-word format even on big-endian systems. |
| // See also GCOVBuffer::readInt64 in LLVM. |
| uint32_t lo = read_32bit_value(); |
| uint32_t hi = read_32bit_value(); |
| return ((uint64_t)hi << 32) | ((uint64_t)lo); |
| } |
| |
| static char *mangle_filename(const char *orig_filename) { |
| char *new_filename; |
| size_t prefix_len; |
| int prefix_strip; |
| const char *prefix = lprofGetPathPrefix(&prefix_strip, &prefix_len); |
| |
| if (prefix == NULL) |
| return strdup(orig_filename); |
| |
| new_filename = malloc(prefix_len + 1 + strlen(orig_filename) + 1); |
| lprofApplyPathPrefix(new_filename, orig_filename, prefix, prefix_len, |
| prefix_strip); |
| |
| return new_filename; |
| } |
| |
| static int map_file(void) { |
| fseek(output_file, 0L, SEEK_END); |
| file_size = ftell(output_file); |
| |
| /* A size of 0 means the file has been created just now (possibly by another |
| * process in lock-after-open race condition). No need to mmap. */ |
| if (file_size == 0) |
| return -1; |
| |
| #if defined(_WIN32) |
| HANDLE mmap_fd; |
| if (fd == -1) |
| mmap_fd = INVALID_HANDLE_VALUE; |
| else |
| mmap_fd = (HANDLE)_get_osfhandle(fd); |
| |
| mmap_handle = CreateFileMapping(mmap_fd, NULL, PAGE_READWRITE, DWORD_HI(file_size), DWORD_LO(file_size), NULL); |
| if (mmap_handle == NULL) { |
| fprintf(stderr, "profiling: %s: cannot create file mapping: %lu\n", |
| filename, GetLastError()); |
| return -1; |
| } |
| |
| write_buffer = MapViewOfFile(mmap_handle, FILE_MAP_WRITE, 0, 0, file_size); |
| if (write_buffer == NULL) { |
| fprintf(stderr, "profiling: %s: cannot map: %lu\n", filename, |
| GetLastError()); |
| CloseHandle(mmap_handle); |
| return -1; |
| } |
| #else |
| write_buffer = mmap(0, file_size, PROT_READ | PROT_WRITE, |
| MAP_FILE | MAP_SHARED, fd, 0); |
| if (write_buffer == (void *)-1) { |
| int errnum = errno; |
| fprintf(stderr, "profiling: %s: cannot map: %s\n", filename, |
| strerror(errnum)); |
| return -1; |
| } |
| #endif |
| |
| return 0; |
| } |
| |
| static void unmap_file(void) { |
| #if defined(_WIN32) |
| if (!UnmapViewOfFile(write_buffer)) { |
| fprintf(stderr, "profiling: %s: cannot unmap mapped view: %lu\n", filename, |
| GetLastError()); |
| } |
| |
| if (!CloseHandle(mmap_handle)) { |
| fprintf(stderr, "profiling: %s: cannot close file mapping handle: %lu\n", |
| filename, GetLastError()); |
| } |
| |
| mmap_handle = NULL; |
| #else |
| if (munmap(write_buffer, file_size) == -1) { |
| int errnum = errno; |
| fprintf(stderr, "profiling: %s: cannot munmap: %s\n", filename, |
| strerror(errnum)); |
| } |
| #endif |
| |
| write_buffer = NULL; |
| file_size = 0; |
| } |
| |
| /* |
| * --- 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, uint32_t version, |
| uint32_t checksum) { |
| const char *mode = "r+b"; |
| filename = mangle_filename(orig_filename); |
| |
| /* Try just opening the file. */ |
| fd = open(filename, O_RDWR | O_BINARY); |
| |
| if (fd == -1) { |
| /* Try creating the file. */ |
| fd = open(filename, O_RDWR | O_CREAT | O_EXCL | O_BINARY, 0644); |
| if (fd != -1) { |
| mode = "w+b"; |
| } else { |
| /* Try creating the directories first then opening the file. */ |
| __llvm_profile_recursive_mkdir(filename); |
| fd = open(filename, O_RDWR | O_CREAT | O_EXCL | O_BINARY, 0644); |
| if (fd != -1) { |
| mode = "w+b"; |
| } else { |
| /* Another process may have created the file just now. |
| * Try opening it without O_CREAT and O_EXCL. */ |
| fd = open(filename, O_RDWR | O_BINARY); |
| if (fd == -1) { |
| /* Bah! It's hopeless. */ |
| int errnum = errno; |
| fprintf(stderr, "profiling: %s: cannot open: %s\n", filename, |
| strerror(errnum)); |
| return; |
| } |
| } |
| } |
| } |
| |
| /* Try to flock the file to serialize concurrent processes writing out to the |
| * same GCDA. This can fail if the filesystem doesn't support it, but in that |
| * case we'll just carry on with the old racy behaviour and hope for the best. |
| */ |
| lprofLockFd(fd); |
| output_file = fdopen(fd, mode); |
| |
| /* Initialize the write buffer. */ |
| new_file = 0; |
| write_buffer = NULL; |
| cur_buffer_size = 0; |
| cur_pos = 0; |
| |
| if (map_file() == -1) { |
| /* The file has been created just now (file_size == 0) or mmap failed |
| * unexpectedly. In the latter case, try to recover by clobbering. */ |
| new_file = 1; |
| write_buffer = NULL; |
| resize_write_buffer(WRITE_BUFFER_SIZE); |
| memset(write_buffer, 0, WRITE_BUFFER_SIZE); |
| } |
| |
| /* gcda file, version, stamp checksum. */ |
| { |
| uint8_t c3 = version >> 24; |
| uint8_t c2 = (version >> 16) & 255; |
| uint8_t c1 = (version >> 8) & 255; |
| gcov_version = c3 >= 'A' ? (c3 - 'A') * 100 + (c2 - '0') * 10 + c1 - '0' |
| : (c3 - '0') * 10 + c1 - '0'; |
| } |
| write_32bit_value(GCOV_DATA_MAGIC); |
| write_32bit_value(version); |
| write_32bit_value(checksum); |
| |
| #ifdef DEBUG_GCDAPROFILING |
| fprintf(stderr, "llvmgcda: [%s]\n", orig_filename); |
| #endif |
| } |
| |
| COMPILER_RT_VISIBILITY |
| void llvm_gcda_emit_function(uint32_t ident, uint32_t func_checksum, |
| uint32_t cfg_checksum) { |
| uint32_t len = 2; |
| int use_extra_checksum = gcov_version >= 47; |
| |
| if (use_extra_checksum) |
| len++; |
| #ifdef DEBUG_GCDAPROFILING |
| fprintf(stderr, "llvmgcda: function id=0x%08x\n", ident); |
| #endif |
| if (!output_file) return; |
| |
| /* function tag */ |
| write_32bit_value(GCOV_TAG_FUNCTION); |
| write_32bit_value(len); |
| write_32bit_value(ident); |
| write_32bit_value(func_checksum); |
| if (use_extra_checksum) |
| write_32bit_value(cfg_checksum); |
| } |
| |
| 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; |
| |
| val = read_32bit_value(); |
| |
| if (val != (uint32_t)-1) { |
| /* There are counters present in the file. Merge them. */ |
| if (val != GCOV_TAG_COUNTER_ARCS) { |
| fprintf(stderr, "profiling: %s: cannot merge previous GCDA file: " |
| "corrupt arc tag (0x%08x)\n", |
| filename, val); |
| return; |
| } |
| |
| val = read_32bit_value(); |
| if (val == (uint32_t)-1 || val / 2 != num_counters) { |
| fprintf(stderr, "profiling: %s: cannot merge previous GCDA file: " |
| "mismatched number of counters (%d)\n", |
| filename, val); |
| return; |
| } |
| |
| old_ctrs = malloc(sizeof(uint64_t) * num_counters); |
| for (i = 0; i < num_counters; ++i) |
| old_ctrs[i] = read_64bit_value(); |
| } |
| |
| cur_pos = save_cur_pos; |
| |
| /* Counter #1 (arcs) tag */ |
| write_32bit_value(GCOV_TAG_COUNTER_ARCS); |
| write_32bit_value(num_counters * 2); |
| for (i = 0; i < num_counters; ++i) { |
| counters[i] += (old_ctrs ? old_ctrs[i] : 0); |
| write_64bit_value(counters[i]); |
| } |
| |
| free(old_ctrs); |
| |
| #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(void) { |
| 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) { |
| /* There are counters present in the file. Merge them. */ |
| uint32_t gcov_tag = |
| gcov_version >= 90 ? GCOV_TAG_OBJECT_SUMMARY : GCOV_TAG_PROGRAM_SUMMARY; |
| if (val != gcov_tag) { |
| fprintf(stderr, |
| "profiling: %s: cannot merge previous run count: " |
| "corrupt object tag (0x%08x)\n", |
| filename, val); |
| return; |
| } |
| |
| val = read_32bit_value(); /* length */ |
| uint32_t prev_runs; |
| if (gcov_version < 90) { |
| read_32bit_value(); |
| read_32bit_value(); |
| prev_runs = read_32bit_value(); |
| } else { |
| prev_runs = read_32bit_value(); |
| read_32bit_value(); |
| } |
| for (uint32_t i = gcov_version < 90 ? 3 : 2; i < val; ++i) |
| 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; |
| |
| if (gcov_version >= 90) { |
| write_32bit_value(GCOV_TAG_OBJECT_SUMMARY); |
| write_32bit_value(2); |
| write_32bit_value(runs); |
| write_32bit_value(0); // sum_max |
| } else { |
| // Before gcov 4.8 (r190952), GCOV_TAG_SUMMARY_LENGTH was 9. r190952 set |
| // GCOV_TAG_SUMMARY_LENGTH to 22. We simply use the smallest length which |
| // can make gcov read "Runs:". |
| write_32bit_value(GCOV_TAG_PROGRAM_SUMMARY); |
| write_32bit_value(3); |
| write_32bit_value(0); |
| write_32bit_value(0); |
| write_32bit_value(runs); |
| } |
| |
| run_counted = 1; |
| |
| #ifdef DEBUG_GCDAPROFILING |
| fprintf(stderr, "llvmgcda: %u runs\n", runs); |
| #endif |
| } |
| |
| COMPILER_RT_VISIBILITY |
| void llvm_gcda_end_file(void) { |
| /* 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); |
| } else { |
| unmap_file(); |
| } |
| |
| fflush(output_file); |
| lprofUnlockFd(fd); |
| fclose(output_file); |
| output_file = NULL; |
| write_buffer = NULL; |
| } |
| free(filename); |
| |
| #ifdef DEBUG_GCDAPROFILING |
| fprintf(stderr, "llvmgcda: -----\n"); |
| #endif |
| } |
| |
| COMPILER_RT_VISIBILITY |
| void llvm_register_writeout_function(fn_ptr fn) { |
| fn_list_insert(&writeout_fn_list, fn); |
| } |
| |
| COMPILER_RT_VISIBILITY |
| void llvm_writeout_files(void) { |
| struct fn_node *curr = writeout_fn_list.head; |
| |
| while (curr) { |
| if (curr->id == CURRENT_ID) { |
| curr->fn(); |
| } |
| curr = curr->next; |
| } |
| } |
| |
| #ifndef _WIN32 |
| // __attribute__((destructor)) and destructors whose priorities are greater than |
| // 100 run before this function and can thus be tracked. The priority is |
| // compatible with GCC 7 onwards. |
| #if __GNUC__ >= 9 |
| #pragma GCC diagnostic ignored "-Wprio-ctor-dtor" |
| #endif |
| __attribute__((destructor(100))) |
| #endif |
| static void llvm_writeout_and_clear(void) { |
| llvm_writeout_files(); |
| fn_list_remove(&writeout_fn_list); |
| } |
| |
| COMPILER_RT_VISIBILITY |
| void llvm_register_reset_function(fn_ptr fn) { |
| fn_list_insert(&reset_fn_list, fn); |
| } |
| |
| COMPILER_RT_VISIBILITY |
| void llvm_delete_reset_function_list(void) { fn_list_remove(&reset_fn_list); } |
| |
| COMPILER_RT_VISIBILITY |
| void llvm_reset_counters(void) { |
| struct fn_node *curr = reset_fn_list.head; |
| |
| while (curr) { |
| if (curr->id == CURRENT_ID) { |
| curr->fn(); |
| } |
| curr = curr->next; |
| } |
| } |
| |
| #if !defined(_WIN32) |
| COMPILER_RT_VISIBILITY |
| pid_t __gcov_fork() { |
| pid_t parent_pid = getpid(); |
| pid_t pid = fork(); |
| |
| if (pid == 0) { |
| pid_t child_pid = getpid(); |
| if (child_pid != parent_pid) { |
| // The pid changed so we've a fork (one could have its own fork function) |
| // Just reset the counters for this child process |
| // threads. |
| llvm_reset_counters(); |
| } |
| } |
| return pid; |
| } |
| #endif |
| |
| COMPILER_RT_VISIBILITY |
| void llvm_gcov_init(fn_ptr wfn, fn_ptr rfn) { |
| static int atexit_ran = 0; |
| |
| if (wfn) |
| llvm_register_writeout_function(wfn); |
| |
| if (rfn) |
| llvm_register_reset_function(rfn); |
| |
| if (atexit_ran == 0) { |
| atexit_ran = 1; |
| |
| /* Make sure we write out the data and delete the data structures. */ |
| atexit(llvm_delete_reset_function_list); |
| #ifdef _WIN32 |
| atexit(llvm_writeout_and_clear); |
| #endif |
| } |
| } |
| |
| void __gcov_dump(void) { |
| for (struct fn_node *f = writeout_fn_list.head; f; f = f->next) |
| f->fn(); |
| } |
| |
| void __gcov_reset(void) { |
| for (struct fn_node *f = reset_fn_list.head; f; f = f->next) |
| f->fn(); |
| } |
| |
| #endif |