10b57cec5SDimitry Andric /*===- InstrProfilingFile.c - Write instrumentation to a file -------------===*\ 20b57cec5SDimitry Andric |* 30b57cec5SDimitry Andric |* Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 40b57cec5SDimitry Andric |* See https://llvm.org/LICENSE.txt for license information. 50b57cec5SDimitry Andric |* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 60b57cec5SDimitry Andric |* 70b57cec5SDimitry Andric \*===----------------------------------------------------------------------===*/ 80b57cec5SDimitry Andric 90b57cec5SDimitry Andric #if !defined(__Fuchsia__) 100b57cec5SDimitry Andric 11fe6060f1SDimitry Andric #include <assert.h> 120b57cec5SDimitry Andric #include <errno.h> 130b57cec5SDimitry Andric #include <stdio.h> 140b57cec5SDimitry Andric #include <stdlib.h> 150b57cec5SDimitry Andric #include <string.h> 160b57cec5SDimitry Andric #ifdef _MSC_VER 170b57cec5SDimitry Andric /* For _alloca. */ 180b57cec5SDimitry Andric #include <malloc.h> 190b57cec5SDimitry Andric #endif 200b57cec5SDimitry Andric #if defined(_WIN32) 210b57cec5SDimitry Andric #include "WindowsMMap.h" 220b57cec5SDimitry Andric /* For _chsize_s */ 230b57cec5SDimitry Andric #include <io.h> 240b57cec5SDimitry Andric #include <process.h> 250b57cec5SDimitry Andric #else 260b57cec5SDimitry Andric #include <sys/file.h> 270b57cec5SDimitry Andric #include <sys/mman.h> 280b57cec5SDimitry Andric #include <unistd.h> 290b57cec5SDimitry Andric #if defined(__linux__) 300b57cec5SDimitry Andric #include <sys/types.h> 310b57cec5SDimitry Andric #endif 320b57cec5SDimitry Andric #endif 330b57cec5SDimitry Andric 340b57cec5SDimitry Andric #include "InstrProfiling.h" 350b57cec5SDimitry Andric #include "InstrProfilingInternal.h" 36480093f4SDimitry Andric #include "InstrProfilingPort.h" 370b57cec5SDimitry Andric #include "InstrProfilingUtil.h" 380b57cec5SDimitry Andric 390b57cec5SDimitry Andric /* From where is profile name specified. 400b57cec5SDimitry Andric * The order the enumerators define their 410b57cec5SDimitry Andric * precedence. Re-order them may lead to 420b57cec5SDimitry Andric * runtime behavior change. */ 430b57cec5SDimitry Andric typedef enum ProfileNameSpecifier { 440b57cec5SDimitry Andric PNS_unknown = 0, 450b57cec5SDimitry Andric PNS_default, 460b57cec5SDimitry Andric PNS_command_line, 470b57cec5SDimitry Andric PNS_environment, 480b57cec5SDimitry Andric PNS_runtime_api 490b57cec5SDimitry Andric } ProfileNameSpecifier; 500b57cec5SDimitry Andric 510b57cec5SDimitry Andric static const char *getPNSStr(ProfileNameSpecifier PNS) { 520b57cec5SDimitry Andric switch (PNS) { 530b57cec5SDimitry Andric case PNS_default: 540b57cec5SDimitry Andric return "default setting"; 550b57cec5SDimitry Andric case PNS_command_line: 560b57cec5SDimitry Andric return "command line"; 570b57cec5SDimitry Andric case PNS_environment: 580b57cec5SDimitry Andric return "environment variable"; 590b57cec5SDimitry Andric case PNS_runtime_api: 600b57cec5SDimitry Andric return "runtime API"; 610b57cec5SDimitry Andric default: 620b57cec5SDimitry Andric return "Unknown"; 630b57cec5SDimitry Andric } 640b57cec5SDimitry Andric } 650b57cec5SDimitry Andric 660b57cec5SDimitry Andric #define MAX_PID_SIZE 16 670b57cec5SDimitry Andric /* Data structure holding the result of parsed filename pattern. */ 680b57cec5SDimitry Andric typedef struct lprofFilename { 690b57cec5SDimitry Andric /* File name string possibly with %p or %h specifiers. */ 700b57cec5SDimitry Andric const char *FilenamePat; 710b57cec5SDimitry Andric /* A flag indicating if FilenamePat's memory is allocated 720b57cec5SDimitry Andric * by runtime. */ 730b57cec5SDimitry Andric unsigned OwnsFilenamePat; 740b57cec5SDimitry Andric const char *ProfilePathPrefix; 750b57cec5SDimitry Andric char PidChars[MAX_PID_SIZE]; 76e8d8bef9SDimitry Andric char *TmpDir; 770b57cec5SDimitry Andric char Hostname[COMPILER_RT_MAX_HOSTLEN]; 780b57cec5SDimitry Andric unsigned NumPids; 790b57cec5SDimitry Andric unsigned NumHosts; 800b57cec5SDimitry Andric /* When in-process merging is enabled, this parameter specifies 810b57cec5SDimitry Andric * the total number of profile data files shared by all the processes 820b57cec5SDimitry Andric * spawned from the same binary. By default the value is 1. If merging 830b57cec5SDimitry Andric * is not enabled, its value should be 0. This parameter is specified 840b57cec5SDimitry Andric * by the %[0-9]m specifier. For instance %2m enables merging using 850b57cec5SDimitry Andric * 2 profile data files. %1m is equivalent to %m. Also %m specifier 860b57cec5SDimitry Andric * can only appear once at the end of the name pattern. */ 870b57cec5SDimitry Andric unsigned MergePoolSize; 880b57cec5SDimitry Andric ProfileNameSpecifier PNS; 890b57cec5SDimitry Andric } lprofFilename; 900b57cec5SDimitry Andric 91e8d8bef9SDimitry Andric static lprofFilename lprofCurFilename = {0, 0, 0, {0}, NULL, 92e8d8bef9SDimitry Andric {0}, 0, 0, 0, PNS_unknown}; 930b57cec5SDimitry Andric 940b57cec5SDimitry Andric static int ProfileMergeRequested = 0; 95349cc55cSDimitry Andric static int getProfileFileSizeForMerging(FILE *ProfileFile, 96349cc55cSDimitry Andric uint64_t *ProfileFileSize); 97349cc55cSDimitry Andric 98349cc55cSDimitry Andric #if defined(__APPLE__) 99349cc55cSDimitry Andric static const int ContinuousModeSupported = 1; 100349cc55cSDimitry Andric static const int UseBiasVar = 0; 101349cc55cSDimitry Andric static const char *FileOpenMode = "a+b"; 102349cc55cSDimitry Andric static void *BiasAddr = NULL; 103349cc55cSDimitry Andric static void *BiasDefaultAddr = NULL; 104349cc55cSDimitry Andric static int mmapForContinuousMode(uint64_t CurrentFileOffset, FILE *File) { 105349cc55cSDimitry Andric /* Get the sizes of various profile data sections. Taken from 106349cc55cSDimitry Andric * __llvm_profile_get_size_for_buffer(). */ 107349cc55cSDimitry Andric const __llvm_profile_data *DataBegin = __llvm_profile_begin_data(); 108349cc55cSDimitry Andric const __llvm_profile_data *DataEnd = __llvm_profile_end_data(); 10904eeddc0SDimitry Andric const char *CountersBegin = __llvm_profile_begin_counters(); 11004eeddc0SDimitry Andric const char *CountersEnd = __llvm_profile_end_counters(); 111349cc55cSDimitry Andric const char *NamesBegin = __llvm_profile_begin_names(); 112349cc55cSDimitry Andric const char *NamesEnd = __llvm_profile_end_names(); 113349cc55cSDimitry Andric const uint64_t NamesSize = (NamesEnd - NamesBegin) * sizeof(char); 114349cc55cSDimitry Andric uint64_t DataSize = __llvm_profile_get_data_size(DataBegin, DataEnd); 11504eeddc0SDimitry Andric uint64_t CountersSize = 11604eeddc0SDimitry Andric __llvm_profile_get_counters_size(CountersBegin, CountersEnd); 117349cc55cSDimitry Andric 118349cc55cSDimitry Andric /* Check that the counter and data sections in this image are 119349cc55cSDimitry Andric * page-aligned. */ 120349cc55cSDimitry Andric unsigned PageSize = getpagesize(); 121349cc55cSDimitry Andric if ((intptr_t)CountersBegin % PageSize != 0) { 122349cc55cSDimitry Andric PROF_ERR("Counters section not page-aligned (start = %p, pagesz = %u).\n", 123349cc55cSDimitry Andric CountersBegin, PageSize); 124349cc55cSDimitry Andric return 1; 125349cc55cSDimitry Andric } 126349cc55cSDimitry Andric if ((intptr_t)DataBegin % PageSize != 0) { 127349cc55cSDimitry Andric PROF_ERR("Data section not page-aligned (start = %p, pagesz = %u).\n", 128349cc55cSDimitry Andric DataBegin, PageSize); 129349cc55cSDimitry Andric return 1; 130349cc55cSDimitry Andric } 131349cc55cSDimitry Andric int Fileno = fileno(File); 132349cc55cSDimitry Andric /* Determine how much padding is needed before/after the counters and 133349cc55cSDimitry Andric * after the names. */ 134349cc55cSDimitry Andric uint64_t PaddingBytesBeforeCounters, PaddingBytesAfterCounters, 135349cc55cSDimitry Andric PaddingBytesAfterNames; 136349cc55cSDimitry Andric __llvm_profile_get_padding_sizes_for_counters( 137349cc55cSDimitry Andric DataSize, CountersSize, NamesSize, &PaddingBytesBeforeCounters, 138349cc55cSDimitry Andric &PaddingBytesAfterCounters, &PaddingBytesAfterNames); 139349cc55cSDimitry Andric 14004eeddc0SDimitry Andric uint64_t PageAlignedCountersLength = CountersSize + PaddingBytesAfterCounters; 14104eeddc0SDimitry Andric uint64_t FileOffsetToCounters = CurrentFileOffset + 14204eeddc0SDimitry Andric sizeof(__llvm_profile_header) + DataSize + 14304eeddc0SDimitry Andric PaddingBytesBeforeCounters; 14481ad6265SDimitry Andric void *CounterMmap = mmap((void *)CountersBegin, PageAlignedCountersLength, 14581ad6265SDimitry Andric PROT_READ | PROT_WRITE, MAP_FIXED | MAP_SHARED, 14681ad6265SDimitry Andric Fileno, FileOffsetToCounters); 147349cc55cSDimitry Andric if (CounterMmap != CountersBegin) { 148349cc55cSDimitry Andric PROF_ERR( 149349cc55cSDimitry Andric "Continuous counter sync mode is enabled, but mmap() failed (%s).\n" 150349cc55cSDimitry Andric " - CountersBegin: %p\n" 151349cc55cSDimitry Andric " - PageAlignedCountersLength: %" PRIu64 "\n" 152349cc55cSDimitry Andric " - Fileno: %d\n" 153349cc55cSDimitry Andric " - FileOffsetToCounters: %" PRIu64 "\n", 154349cc55cSDimitry Andric strerror(errno), CountersBegin, PageAlignedCountersLength, Fileno, 155349cc55cSDimitry Andric FileOffsetToCounters); 156349cc55cSDimitry Andric return 1; 157349cc55cSDimitry Andric } 158349cc55cSDimitry Andric return 0; 159349cc55cSDimitry Andric } 160349cc55cSDimitry Andric #elif defined(__ELF__) || defined(_WIN32) 161349cc55cSDimitry Andric 162349cc55cSDimitry Andric #define INSTR_PROF_PROFILE_COUNTER_BIAS_DEFAULT_VAR \ 163349cc55cSDimitry Andric INSTR_PROF_CONCAT(INSTR_PROF_PROFILE_COUNTER_BIAS_VAR, _default) 164bdd1243dSDimitry Andric COMPILER_RT_VISIBILITY intptr_t INSTR_PROF_PROFILE_COUNTER_BIAS_DEFAULT_VAR = 0; 165349cc55cSDimitry Andric 166349cc55cSDimitry Andric /* This variable is a weak external reference which could be used to detect 167349cc55cSDimitry Andric * whether or not the compiler defined this symbol. */ 168349cc55cSDimitry Andric #if defined(_MSC_VER) 169349cc55cSDimitry Andric COMPILER_RT_VISIBILITY extern intptr_t INSTR_PROF_PROFILE_COUNTER_BIAS_VAR; 170349cc55cSDimitry Andric #if defined(_M_IX86) || defined(__i386__) 171349cc55cSDimitry Andric #define WIN_SYM_PREFIX "_" 172349cc55cSDimitry Andric #else 173349cc55cSDimitry Andric #define WIN_SYM_PREFIX 174349cc55cSDimitry Andric #endif 175349cc55cSDimitry Andric #pragma comment( \ 176349cc55cSDimitry Andric linker, "/alternatename:" WIN_SYM_PREFIX INSTR_PROF_QUOTE( \ 177349cc55cSDimitry Andric INSTR_PROF_PROFILE_COUNTER_BIAS_VAR) "=" WIN_SYM_PREFIX \ 178349cc55cSDimitry Andric INSTR_PROF_QUOTE(INSTR_PROF_PROFILE_COUNTER_BIAS_DEFAULT_VAR)) 179349cc55cSDimitry Andric #else 180349cc55cSDimitry Andric COMPILER_RT_VISIBILITY extern intptr_t INSTR_PROF_PROFILE_COUNTER_BIAS_VAR 181349cc55cSDimitry Andric __attribute__((weak, alias(INSTR_PROF_QUOTE( 182349cc55cSDimitry Andric INSTR_PROF_PROFILE_COUNTER_BIAS_DEFAULT_VAR)))); 183349cc55cSDimitry Andric #endif 184349cc55cSDimitry Andric static const int ContinuousModeSupported = 1; 185349cc55cSDimitry Andric static const int UseBiasVar = 1; 186349cc55cSDimitry Andric /* TODO: If there are two DSOs, the second DSO initilization will truncate the 187349cc55cSDimitry Andric * first profile file. */ 188349cc55cSDimitry Andric static const char *FileOpenMode = "w+b"; 189349cc55cSDimitry Andric /* This symbol is defined by the compiler when runtime counter relocation is 190349cc55cSDimitry Andric * used and runtime provides a weak alias so we can check if it's defined. */ 191349cc55cSDimitry Andric static void *BiasAddr = &INSTR_PROF_PROFILE_COUNTER_BIAS_VAR; 192349cc55cSDimitry Andric static void *BiasDefaultAddr = &INSTR_PROF_PROFILE_COUNTER_BIAS_DEFAULT_VAR; 193349cc55cSDimitry Andric static int mmapForContinuousMode(uint64_t CurrentFileOffset, FILE *File) { 194349cc55cSDimitry Andric /* Get the sizes of various profile data sections. Taken from 195349cc55cSDimitry Andric * __llvm_profile_get_size_for_buffer(). */ 196349cc55cSDimitry Andric const __llvm_profile_data *DataBegin = __llvm_profile_begin_data(); 197349cc55cSDimitry Andric const __llvm_profile_data *DataEnd = __llvm_profile_end_data(); 19804eeddc0SDimitry Andric const char *CountersBegin = __llvm_profile_begin_counters(); 19904eeddc0SDimitry Andric const char *CountersEnd = __llvm_profile_end_counters(); 200349cc55cSDimitry Andric uint64_t DataSize = __llvm_profile_get_data_size(DataBegin, DataEnd); 201349cc55cSDimitry Andric /* Get the file size. */ 202349cc55cSDimitry Andric uint64_t FileSize = 0; 203349cc55cSDimitry Andric if (getProfileFileSizeForMerging(File, &FileSize)) 204349cc55cSDimitry Andric return 1; 205349cc55cSDimitry Andric 206349cc55cSDimitry Andric /* Map the profile. */ 207349cc55cSDimitry Andric char *Profile = (char *)mmap(NULL, FileSize, PROT_READ | PROT_WRITE, 208349cc55cSDimitry Andric MAP_SHARED, fileno(File), 0); 209349cc55cSDimitry Andric if (Profile == MAP_FAILED) { 210349cc55cSDimitry Andric PROF_ERR("Unable to mmap profile: %s\n", strerror(errno)); 211349cc55cSDimitry Andric return 1; 212349cc55cSDimitry Andric } 213349cc55cSDimitry Andric const uint64_t CountersOffsetInBiasMode = 21404eeddc0SDimitry Andric sizeof(__llvm_profile_header) + __llvm_write_binary_ids(NULL) + DataSize; 215349cc55cSDimitry Andric /* Update the profile fields based on the current mapping. */ 216349cc55cSDimitry Andric INSTR_PROF_PROFILE_COUNTER_BIAS_VAR = 217349cc55cSDimitry Andric (intptr_t)Profile - (uintptr_t)CountersBegin + CountersOffsetInBiasMode; 218349cc55cSDimitry Andric 219349cc55cSDimitry Andric /* Return the memory allocated for counters to OS. */ 220349cc55cSDimitry Andric lprofReleaseMemoryPagesToOS((uintptr_t)CountersBegin, (uintptr_t)CountersEnd); 221349cc55cSDimitry Andric return 0; 222349cc55cSDimitry Andric } 223349cc55cSDimitry Andric #else 224349cc55cSDimitry Andric static const int ContinuousModeSupported = 0; 225349cc55cSDimitry Andric static const int UseBiasVar = 0; 226349cc55cSDimitry Andric static const char *FileOpenMode = "a+b"; 227349cc55cSDimitry Andric static void *BiasAddr = NULL; 228349cc55cSDimitry Andric static void *BiasDefaultAddr = NULL; 229349cc55cSDimitry Andric static int mmapForContinuousMode(uint64_t CurrentFileOffset, FILE *File) { 230349cc55cSDimitry Andric return 0; 231349cc55cSDimitry Andric } 232349cc55cSDimitry Andric #endif 233349cc55cSDimitry Andric 23481ad6265SDimitry Andric static int isProfileMergeRequested(void) { return ProfileMergeRequested; } 2350b57cec5SDimitry Andric static void setProfileMergeRequested(int EnableMerge) { 2360b57cec5SDimitry Andric ProfileMergeRequested = EnableMerge; 2370b57cec5SDimitry Andric } 2380b57cec5SDimitry Andric 2390b57cec5SDimitry Andric static FILE *ProfileFile = NULL; 24081ad6265SDimitry Andric static FILE *getProfileFile(void) { return ProfileFile; } 2410b57cec5SDimitry Andric static void setProfileFile(FILE *File) { ProfileFile = File; } 2420b57cec5SDimitry Andric 24381ad6265SDimitry Andric static int getCurFilenameLength(void); 2440b57cec5SDimitry Andric static const char *getCurFilename(char *FilenameBuf, int ForceUseBuf); 24581ad6265SDimitry Andric static unsigned doMerging(void) { 2460b57cec5SDimitry Andric return lprofCurFilename.MergePoolSize || isProfileMergeRequested(); 2470b57cec5SDimitry Andric } 2480b57cec5SDimitry Andric 2490b57cec5SDimitry Andric /* Return 1 if there is an error, otherwise return 0. */ 2500b57cec5SDimitry Andric static uint32_t fileWriter(ProfDataWriter *This, ProfDataIOVec *IOVecs, 2510b57cec5SDimitry Andric uint32_t NumIOVecs) { 2520b57cec5SDimitry Andric uint32_t I; 2530b57cec5SDimitry Andric FILE *File = (FILE *)This->WriterCtx; 254480093f4SDimitry Andric char Zeroes[sizeof(uint64_t)] = {0}; 2550b57cec5SDimitry Andric for (I = 0; I < NumIOVecs; I++) { 2560b57cec5SDimitry Andric if (IOVecs[I].Data) { 2570b57cec5SDimitry Andric if (fwrite(IOVecs[I].Data, IOVecs[I].ElmSize, IOVecs[I].NumElm, File) != 2580b57cec5SDimitry Andric IOVecs[I].NumElm) 2590b57cec5SDimitry Andric return 1; 260480093f4SDimitry Andric } else if (IOVecs[I].UseZeroPadding) { 261480093f4SDimitry Andric size_t BytesToWrite = IOVecs[I].ElmSize * IOVecs[I].NumElm; 262480093f4SDimitry Andric while (BytesToWrite > 0) { 263480093f4SDimitry Andric size_t PartialWriteLen = 264480093f4SDimitry Andric (sizeof(uint64_t) > BytesToWrite) ? BytesToWrite : sizeof(uint64_t); 265480093f4SDimitry Andric if (fwrite(Zeroes, sizeof(uint8_t), PartialWriteLen, File) != 266480093f4SDimitry Andric PartialWriteLen) { 267480093f4SDimitry Andric return 1; 268480093f4SDimitry Andric } 269480093f4SDimitry Andric BytesToWrite -= PartialWriteLen; 270480093f4SDimitry Andric } 2710b57cec5SDimitry Andric } else { 2720b57cec5SDimitry Andric if (fseek(File, IOVecs[I].ElmSize * IOVecs[I].NumElm, SEEK_CUR) == -1) 2730b57cec5SDimitry Andric return 1; 2740b57cec5SDimitry Andric } 2750b57cec5SDimitry Andric } 2760b57cec5SDimitry Andric return 0; 2770b57cec5SDimitry Andric } 2780b57cec5SDimitry Andric 2790b57cec5SDimitry Andric /* TODO: make buffer size controllable by an internal option, and compiler can pass the size 2800b57cec5SDimitry Andric to runtime via a variable. */ 2810b57cec5SDimitry Andric static uint32_t orderFileWriter(FILE *File, const uint32_t *DataStart) { 2820b57cec5SDimitry Andric if (fwrite(DataStart, sizeof(uint32_t), INSTR_ORDER_FILE_BUFFER_SIZE, File) != 2830b57cec5SDimitry Andric INSTR_ORDER_FILE_BUFFER_SIZE) 2840b57cec5SDimitry Andric return 1; 2850b57cec5SDimitry Andric return 0; 2860b57cec5SDimitry Andric } 2870b57cec5SDimitry Andric 2880b57cec5SDimitry Andric static void initFileWriter(ProfDataWriter *This, FILE *File) { 2890b57cec5SDimitry Andric This->Write = fileWriter; 2900b57cec5SDimitry Andric This->WriterCtx = File; 2910b57cec5SDimitry Andric } 2920b57cec5SDimitry Andric 2930b57cec5SDimitry Andric COMPILER_RT_VISIBILITY ProfBufferIO * 2940b57cec5SDimitry Andric lprofCreateBufferIOInternal(void *File, uint32_t BufferSz) { 2950b57cec5SDimitry Andric FreeHook = &free; 2960b57cec5SDimitry Andric DynamicBufferIOBuffer = (uint8_t *)calloc(BufferSz, 1); 2970b57cec5SDimitry Andric VPBufferSize = BufferSz; 2980b57cec5SDimitry Andric ProfDataWriter *fileWriter = 2990b57cec5SDimitry Andric (ProfDataWriter *)calloc(sizeof(ProfDataWriter), 1); 3000b57cec5SDimitry Andric initFileWriter(fileWriter, File); 3010b57cec5SDimitry Andric ProfBufferIO *IO = lprofCreateBufferIO(fileWriter); 3020b57cec5SDimitry Andric IO->OwnFileWriter = 1; 3030b57cec5SDimitry Andric return IO; 3040b57cec5SDimitry Andric } 3050b57cec5SDimitry Andric 30681ad6265SDimitry Andric static void setupIOBuffer(void) { 3070b57cec5SDimitry Andric const char *BufferSzStr = 0; 3080b57cec5SDimitry Andric BufferSzStr = getenv("LLVM_VP_BUFFER_SIZE"); 3090b57cec5SDimitry Andric if (BufferSzStr && BufferSzStr[0]) { 3100b57cec5SDimitry Andric VPBufferSize = atoi(BufferSzStr); 3110b57cec5SDimitry Andric DynamicBufferIOBuffer = (uint8_t *)calloc(VPBufferSize, 1); 3120b57cec5SDimitry Andric } 3130b57cec5SDimitry Andric } 3140b57cec5SDimitry Andric 315480093f4SDimitry Andric /* Get the size of the profile file. If there are any errors, print the 316480093f4SDimitry Andric * message under the assumption that the profile is being read for merging 317480093f4SDimitry Andric * purposes, and return -1. Otherwise return the file size in the inout param 318480093f4SDimitry Andric * \p ProfileFileSize. */ 319480093f4SDimitry Andric static int getProfileFileSizeForMerging(FILE *ProfileFile, 320480093f4SDimitry Andric uint64_t *ProfileFileSize) { 321480093f4SDimitry Andric if (fseek(ProfileFile, 0L, SEEK_END) == -1) { 322480093f4SDimitry Andric PROF_ERR("Unable to merge profile data, unable to get size: %s\n", 323480093f4SDimitry Andric strerror(errno)); 324480093f4SDimitry Andric return -1; 325480093f4SDimitry Andric } 326480093f4SDimitry Andric *ProfileFileSize = ftell(ProfileFile); 327480093f4SDimitry Andric 328480093f4SDimitry Andric /* Restore file offset. */ 329480093f4SDimitry Andric if (fseek(ProfileFile, 0L, SEEK_SET) == -1) { 330480093f4SDimitry Andric PROF_ERR("Unable to merge profile data, unable to rewind: %s\n", 331480093f4SDimitry Andric strerror(errno)); 332480093f4SDimitry Andric return -1; 333480093f4SDimitry Andric } 334480093f4SDimitry Andric 335480093f4SDimitry Andric if (*ProfileFileSize > 0 && 336480093f4SDimitry Andric *ProfileFileSize < sizeof(__llvm_profile_header)) { 337480093f4SDimitry Andric PROF_WARN("Unable to merge profile data: %s\n", 338480093f4SDimitry Andric "source profile file is too small."); 339480093f4SDimitry Andric return -1; 340480093f4SDimitry Andric } 341480093f4SDimitry Andric return 0; 342480093f4SDimitry Andric } 343480093f4SDimitry Andric 344480093f4SDimitry Andric /* mmap() \p ProfileFile for profile merging purposes, assuming that an 345480093f4SDimitry Andric * exclusive lock is held on the file and that \p ProfileFileSize is the 346480093f4SDimitry Andric * length of the file. Return the mmap'd buffer in the inout variable 347480093f4SDimitry Andric * \p ProfileBuffer. Returns -1 on failure. On success, the caller is 348480093f4SDimitry Andric * responsible for unmapping the mmap'd buffer in \p ProfileBuffer. */ 349480093f4SDimitry Andric static int mmapProfileForMerging(FILE *ProfileFile, uint64_t ProfileFileSize, 350480093f4SDimitry Andric char **ProfileBuffer) { 351480093f4SDimitry Andric *ProfileBuffer = mmap(NULL, ProfileFileSize, PROT_READ, MAP_SHARED | MAP_FILE, 352480093f4SDimitry Andric fileno(ProfileFile), 0); 353480093f4SDimitry Andric if (*ProfileBuffer == MAP_FAILED) { 354480093f4SDimitry Andric PROF_ERR("Unable to merge profile data, mmap failed: %s\n", 355480093f4SDimitry Andric strerror(errno)); 356480093f4SDimitry Andric return -1; 357480093f4SDimitry Andric } 358480093f4SDimitry Andric 359480093f4SDimitry Andric if (__llvm_profile_check_compatibility(*ProfileBuffer, ProfileFileSize)) { 360480093f4SDimitry Andric (void)munmap(*ProfileBuffer, ProfileFileSize); 361480093f4SDimitry Andric PROF_WARN("Unable to merge profile data: %s\n", 362480093f4SDimitry Andric "source profile file is not compatible."); 363480093f4SDimitry Andric return -1; 364480093f4SDimitry Andric } 365480093f4SDimitry Andric return 0; 366480093f4SDimitry Andric } 367480093f4SDimitry Andric 3680b57cec5SDimitry Andric /* Read profile data in \c ProfileFile and merge with in-memory 3690b57cec5SDimitry Andric profile counters. Returns -1 if there is fatal error, otheriwse 3700b57cec5SDimitry Andric 0 is returned. Returning 0 does not mean merge is actually 3710b57cec5SDimitry Andric performed. If merge is actually done, *MergeDone is set to 1. 3720b57cec5SDimitry Andric */ 3730b57cec5SDimitry Andric static int doProfileMerging(FILE *ProfileFile, int *MergeDone) { 3740b57cec5SDimitry Andric uint64_t ProfileFileSize; 3750b57cec5SDimitry Andric char *ProfileBuffer; 3760b57cec5SDimitry Andric 377480093f4SDimitry Andric /* Get the size of the profile on disk. */ 378480093f4SDimitry Andric if (getProfileFileSizeForMerging(ProfileFile, &ProfileFileSize) == -1) 3790b57cec5SDimitry Andric return -1; 3800b57cec5SDimitry Andric 3810b57cec5SDimitry Andric /* Nothing to merge. */ 382480093f4SDimitry Andric if (!ProfileFileSize) 3830b57cec5SDimitry Andric return 0; 3840b57cec5SDimitry Andric 385480093f4SDimitry Andric /* mmap() the profile and check that it is compatible with the data in 386480093f4SDimitry Andric * the current image. */ 387480093f4SDimitry Andric if (mmapProfileForMerging(ProfileFile, ProfileFileSize, &ProfileBuffer) == -1) 3880b57cec5SDimitry Andric return -1; 3890b57cec5SDimitry Andric 3900b57cec5SDimitry Andric /* Now start merging */ 391fe6060f1SDimitry Andric if (__llvm_profile_merge_from_buffer(ProfileBuffer, ProfileFileSize)) { 392fe6060f1SDimitry Andric PROF_ERR("%s\n", "Invalid profile data to merge"); 393fe6060f1SDimitry Andric (void)munmap(ProfileBuffer, ProfileFileSize); 394fe6060f1SDimitry Andric return -1; 395fe6060f1SDimitry Andric } 3960b57cec5SDimitry Andric 397fe6060f1SDimitry Andric // Truncate the file in case merging of value profile did not happen to 3980b57cec5SDimitry Andric // prevent from leaving garbage data at the end of the profile file. 399fe6060f1SDimitry Andric (void)COMPILER_RT_FTRUNCATE(ProfileFile, 400fe6060f1SDimitry Andric __llvm_profile_get_size_for_buffer()); 4010b57cec5SDimitry Andric 4020b57cec5SDimitry Andric (void)munmap(ProfileBuffer, ProfileFileSize); 4030b57cec5SDimitry Andric *MergeDone = 1; 4040b57cec5SDimitry Andric 4050b57cec5SDimitry Andric return 0; 4060b57cec5SDimitry Andric } 4070b57cec5SDimitry Andric 4080b57cec5SDimitry Andric /* Create the directory holding the file, if needed. */ 4090b57cec5SDimitry Andric static void createProfileDir(const char *Filename) { 4100b57cec5SDimitry Andric size_t Length = strlen(Filename); 4110b57cec5SDimitry Andric if (lprofFindFirstDirSeparator(Filename)) { 4120b57cec5SDimitry Andric char *Copy = (char *)COMPILER_RT_ALLOCA(Length + 1); 4130b57cec5SDimitry Andric strncpy(Copy, Filename, Length + 1); 4140b57cec5SDimitry Andric __llvm_profile_recursive_mkdir(Copy); 4150b57cec5SDimitry Andric } 4160b57cec5SDimitry Andric } 4170b57cec5SDimitry Andric 4180b57cec5SDimitry Andric /* Open the profile data for merging. It opens the file in r+b mode with 4190b57cec5SDimitry Andric * file locking. If the file has content which is compatible with the 4200b57cec5SDimitry Andric * current process, it also reads in the profile data in the file and merge 4210b57cec5SDimitry Andric * it with in-memory counters. After the profile data is merged in memory, 4220b57cec5SDimitry Andric * the original profile data is truncated and gets ready for the profile 4230b57cec5SDimitry Andric * dumper. With profile merging enabled, each executable as well as any of 4240b57cec5SDimitry Andric * its instrumented shared libraries dump profile data into their own data file. 4250b57cec5SDimitry Andric */ 4260b57cec5SDimitry Andric static FILE *openFileForMerging(const char *ProfileFileName, int *MergeDone) { 4278a4dda33SDimitry Andric FILE *ProfileFile = NULL; 4280b57cec5SDimitry Andric int rc; 4290b57cec5SDimitry Andric 4308a4dda33SDimitry Andric ProfileFile = getProfileFile(); 4318a4dda33SDimitry Andric if (ProfileFile) { 4328a4dda33SDimitry Andric lprofLockFileHandle(ProfileFile); 4338a4dda33SDimitry Andric } else { 4340b57cec5SDimitry Andric createProfileDir(ProfileFileName); 4350b57cec5SDimitry Andric ProfileFile = lprofOpenFileEx(ProfileFileName); 4360b57cec5SDimitry Andric } 4370b57cec5SDimitry Andric if (!ProfileFile) 4380b57cec5SDimitry Andric return NULL; 4390b57cec5SDimitry Andric 4400b57cec5SDimitry Andric rc = doProfileMerging(ProfileFile, MergeDone); 4410b57cec5SDimitry Andric if (rc || (!*MergeDone && COMPILER_RT_FTRUNCATE(ProfileFile, 0L)) || 4420b57cec5SDimitry Andric fseek(ProfileFile, 0L, SEEK_SET) == -1) { 4430b57cec5SDimitry Andric PROF_ERR("Profile Merging of file %s failed: %s\n", ProfileFileName, 4440b57cec5SDimitry Andric strerror(errno)); 4450b57cec5SDimitry Andric fclose(ProfileFile); 4460b57cec5SDimitry Andric return NULL; 4470b57cec5SDimitry Andric } 4480b57cec5SDimitry Andric return ProfileFile; 4490b57cec5SDimitry Andric } 4500b57cec5SDimitry Andric 4510b57cec5SDimitry Andric static FILE *getFileObject(const char *OutputName) { 4520b57cec5SDimitry Andric FILE *File; 4530b57cec5SDimitry Andric File = getProfileFile(); 4540b57cec5SDimitry Andric if (File != NULL) { 4550b57cec5SDimitry Andric return File; 4560b57cec5SDimitry Andric } 4570b57cec5SDimitry Andric 4580b57cec5SDimitry Andric return fopen(OutputName, "ab"); 4590b57cec5SDimitry Andric } 4600b57cec5SDimitry Andric 4610b57cec5SDimitry Andric /* Write profile data to file \c OutputName. */ 4620b57cec5SDimitry Andric static int writeFile(const char *OutputName) { 4630b57cec5SDimitry Andric int RetVal; 4640b57cec5SDimitry Andric FILE *OutputFile; 4650b57cec5SDimitry Andric 4660b57cec5SDimitry Andric int MergeDone = 0; 4670b57cec5SDimitry Andric VPMergeHook = &lprofMergeValueProfData; 4680b57cec5SDimitry Andric if (doMerging()) 4690b57cec5SDimitry Andric OutputFile = openFileForMerging(OutputName, &MergeDone); 4700b57cec5SDimitry Andric else 4710b57cec5SDimitry Andric OutputFile = getFileObject(OutputName); 4720b57cec5SDimitry Andric 4730b57cec5SDimitry Andric if (!OutputFile) 4740b57cec5SDimitry Andric return -1; 4750b57cec5SDimitry Andric 4760b57cec5SDimitry Andric FreeHook = &free; 4770b57cec5SDimitry Andric setupIOBuffer(); 4780b57cec5SDimitry Andric ProfDataWriter fileWriter; 4790b57cec5SDimitry Andric initFileWriter(&fileWriter, OutputFile); 4800b57cec5SDimitry Andric RetVal = lprofWriteData(&fileWriter, lprofGetVPDataReader(), MergeDone); 4810b57cec5SDimitry Andric 4820b57cec5SDimitry Andric if (OutputFile == getProfileFile()) { 4830b57cec5SDimitry Andric fflush(OutputFile); 4848a4dda33SDimitry Andric if (doMerging()) { 4858a4dda33SDimitry Andric lprofUnlockFileHandle(OutputFile); 4868a4dda33SDimitry Andric } 4870b57cec5SDimitry Andric } else { 4880b57cec5SDimitry Andric fclose(OutputFile); 4890b57cec5SDimitry Andric } 4900b57cec5SDimitry Andric 4910b57cec5SDimitry Andric return RetVal; 4920b57cec5SDimitry Andric } 4930b57cec5SDimitry Andric 4940b57cec5SDimitry Andric /* Write order data to file \c OutputName. */ 4950b57cec5SDimitry Andric static int writeOrderFile(const char *OutputName) { 4960b57cec5SDimitry Andric int RetVal; 4970b57cec5SDimitry Andric FILE *OutputFile; 4980b57cec5SDimitry Andric 4990b57cec5SDimitry Andric OutputFile = fopen(OutputName, "w"); 5000b57cec5SDimitry Andric 5010b57cec5SDimitry Andric if (!OutputFile) { 5020b57cec5SDimitry Andric PROF_WARN("can't open file with mode ab: %s\n", OutputName); 5030b57cec5SDimitry Andric return -1; 5040b57cec5SDimitry Andric } 5050b57cec5SDimitry Andric 5060b57cec5SDimitry Andric FreeHook = &free; 5070b57cec5SDimitry Andric setupIOBuffer(); 5080b57cec5SDimitry Andric const uint32_t *DataBegin = __llvm_profile_begin_orderfile(); 5090b57cec5SDimitry Andric RetVal = orderFileWriter(OutputFile, DataBegin); 5100b57cec5SDimitry Andric 5110b57cec5SDimitry Andric fclose(OutputFile); 5120b57cec5SDimitry Andric return RetVal; 5130b57cec5SDimitry Andric } 5140b57cec5SDimitry Andric 515480093f4SDimitry Andric #define LPROF_INIT_ONCE_ENV "__LLVM_PROFILE_RT_INIT_ONCE" 516480093f4SDimitry Andric 5170b57cec5SDimitry Andric static void truncateCurrentFile(void) { 5180b57cec5SDimitry Andric const char *Filename; 5190b57cec5SDimitry Andric char *FilenameBuf; 5200b57cec5SDimitry Andric FILE *File; 5210b57cec5SDimitry Andric int Length; 5220b57cec5SDimitry Andric 5230b57cec5SDimitry Andric Length = getCurFilenameLength(); 5240b57cec5SDimitry Andric FilenameBuf = (char *)COMPILER_RT_ALLOCA(Length + 1); 5250b57cec5SDimitry Andric Filename = getCurFilename(FilenameBuf, 0); 5260b57cec5SDimitry Andric if (!Filename) 5270b57cec5SDimitry Andric return; 5280b57cec5SDimitry Andric 529480093f4SDimitry Andric /* Only create the profile directory and truncate an existing profile once. 530480093f4SDimitry Andric * In continuous mode, this is necessary, as the profile is written-to by the 531480093f4SDimitry Andric * runtime initializer. */ 532480093f4SDimitry Andric int initialized = getenv(LPROF_INIT_ONCE_ENV) != NULL; 533480093f4SDimitry Andric if (initialized) 534480093f4SDimitry Andric return; 535480093f4SDimitry Andric #if defined(_WIN32) 536480093f4SDimitry Andric _putenv(LPROF_INIT_ONCE_ENV "=" LPROF_INIT_ONCE_ENV); 537480093f4SDimitry Andric #else 538480093f4SDimitry Andric setenv(LPROF_INIT_ONCE_ENV, LPROF_INIT_ONCE_ENV, 1); 539480093f4SDimitry Andric #endif 540480093f4SDimitry Andric 541480093f4SDimitry Andric /* Create the profile dir (even if online merging is enabled), so that 542480093f4SDimitry Andric * the profile file can be set up if continuous mode is enabled. */ 543480093f4SDimitry Andric createProfileDir(Filename); 544480093f4SDimitry Andric 545480093f4SDimitry Andric /* By pass file truncation to allow online raw profile merging. */ 5460b57cec5SDimitry Andric if (lprofCurFilename.MergePoolSize) 5470b57cec5SDimitry Andric return; 5480b57cec5SDimitry Andric 5490b57cec5SDimitry Andric /* Truncate the file. Later we'll reopen and append. */ 5500b57cec5SDimitry Andric File = fopen(Filename, "w"); 5510b57cec5SDimitry Andric if (!File) 5520b57cec5SDimitry Andric return; 5530b57cec5SDimitry Andric fclose(File); 5540b57cec5SDimitry Andric } 5550b57cec5SDimitry Andric 556480093f4SDimitry Andric /* Write a partial profile to \p Filename, which is required to be backed by 557480093f4SDimitry Andric * the open file object \p File. */ 558480093f4SDimitry Andric static int writeProfileWithFileObject(const char *Filename, FILE *File) { 559480093f4SDimitry Andric setProfileFile(File); 560480093f4SDimitry Andric int rc = writeFile(Filename); 561480093f4SDimitry Andric if (rc) 562480093f4SDimitry Andric PROF_ERR("Failed to write file \"%s\": %s\n", Filename, strerror(errno)); 563480093f4SDimitry Andric setProfileFile(NULL); 564480093f4SDimitry Andric return rc; 565480093f4SDimitry Andric } 566480093f4SDimitry Andric 567480093f4SDimitry Andric static void initializeProfileForContinuousMode(void) { 568480093f4SDimitry Andric if (!__llvm_profile_is_continuous_mode_enabled()) 569480093f4SDimitry Andric return; 570349cc55cSDimitry Andric if (!ContinuousModeSupported) { 571349cc55cSDimitry Andric PROF_ERR("%s\n", "continuous mode is unsupported on this platform"); 572480093f4SDimitry Andric return; 573480093f4SDimitry Andric } 574349cc55cSDimitry Andric if (UseBiasVar && BiasAddr == BiasDefaultAddr) { 575fe6060f1SDimitry Andric PROF_ERR("%s\n", "__llvm_profile_counter_bias is undefined"); 576fe6060f1SDimitry Andric return; 577fe6060f1SDimitry Andric } 578fe6060f1SDimitry Andric 579349cc55cSDimitry Andric /* Get the sizes of counter section. */ 58004eeddc0SDimitry Andric uint64_t CountersSize = __llvm_profile_get_counters_size( 58104eeddc0SDimitry Andric __llvm_profile_begin_counters(), __llvm_profile_end_counters()); 582fe6060f1SDimitry Andric 583fe6060f1SDimitry Andric int Length = getCurFilenameLength(); 584fe6060f1SDimitry Andric char *FilenameBuf = (char *)COMPILER_RT_ALLOCA(Length + 1); 585fe6060f1SDimitry Andric const char *Filename = getCurFilename(FilenameBuf, 0); 586fe6060f1SDimitry Andric if (!Filename) 587fe6060f1SDimitry Andric return; 588fe6060f1SDimitry Andric 589fe6060f1SDimitry Andric FILE *File = NULL; 590349cc55cSDimitry Andric uint64_t CurrentFileOffset = 0; 591349cc55cSDimitry Andric if (doMerging()) { 592349cc55cSDimitry Andric /* We are merging profiles. Map the counter section as shared memory into 593349cc55cSDimitry Andric * the profile, i.e. into each participating process. An increment in one 594349cc55cSDimitry Andric * process should be visible to every other process with the same counter 595349cc55cSDimitry Andric * section mapped. */ 596fe6060f1SDimitry Andric File = lprofOpenFileEx(Filename); 597fe6060f1SDimitry Andric if (!File) 598fe6060f1SDimitry Andric return; 599fe6060f1SDimitry Andric 600fe6060f1SDimitry Andric uint64_t ProfileFileSize = 0; 601fe6060f1SDimitry Andric if (getProfileFileSizeForMerging(File, &ProfileFileSize) == -1) { 602fe6060f1SDimitry Andric lprofUnlockFileHandle(File); 603fe6060f1SDimitry Andric fclose(File); 604fe6060f1SDimitry Andric return; 605fe6060f1SDimitry Andric } 606349cc55cSDimitry Andric if (ProfileFileSize == 0) { 607349cc55cSDimitry Andric /* Grow the profile so that mmap() can succeed. Leak the file handle, as 608349cc55cSDimitry Andric * the file should stay open. */ 609349cc55cSDimitry Andric if (writeProfileWithFileObject(Filename, File) != 0) { 610349cc55cSDimitry Andric lprofUnlockFileHandle(File); 611fe6060f1SDimitry Andric fclose(File); 612fe6060f1SDimitry Andric return; 613fe6060f1SDimitry Andric } 614fe6060f1SDimitry Andric } else { 615fe6060f1SDimitry Andric /* The merged profile has a non-zero length. Check that it is compatible 616fe6060f1SDimitry Andric * with the data in this process. */ 617349cc55cSDimitry Andric char *ProfileBuffer; 618349cc55cSDimitry Andric if (mmapProfileForMerging(File, ProfileFileSize, &ProfileBuffer) == -1) { 619349cc55cSDimitry Andric lprofUnlockFileHandle(File); 620349cc55cSDimitry Andric fclose(File); 621349cc55cSDimitry Andric return; 622349cc55cSDimitry Andric } 623349cc55cSDimitry Andric (void)munmap(ProfileBuffer, ProfileFileSize); 624349cc55cSDimitry Andric } 625349cc55cSDimitry Andric } else { 626349cc55cSDimitry Andric File = fopen(Filename, FileOpenMode); 627349cc55cSDimitry Andric if (!File) 628349cc55cSDimitry Andric return; 629349cc55cSDimitry Andric /* Check that the offset within the file is page-aligned. */ 630349cc55cSDimitry Andric CurrentFileOffset = ftell(File); 631349cc55cSDimitry Andric unsigned PageSize = getpagesize(); 632349cc55cSDimitry Andric if (CurrentFileOffset % PageSize != 0) { 633349cc55cSDimitry Andric PROF_ERR("Continuous counter sync mode is enabled, but raw profile is not" 634349cc55cSDimitry Andric "page-aligned. CurrentFileOffset = %" PRIu64 ", pagesz = %u.\n", 635349cc55cSDimitry Andric (uint64_t)CurrentFileOffset, PageSize); 636349cc55cSDimitry Andric return; 637349cc55cSDimitry Andric } 638349cc55cSDimitry Andric if (writeProfileWithFileObject(Filename, File) != 0) { 639fe6060f1SDimitry Andric fclose(File); 640fe6060f1SDimitry Andric return; 641fe6060f1SDimitry Andric } 642fe6060f1SDimitry Andric } 643fe6060f1SDimitry Andric 644349cc55cSDimitry Andric /* mmap() the profile counters so long as there is at least one counter. 645349cc55cSDimitry Andric * If there aren't any counters, mmap() would fail with EINVAL. */ 646349cc55cSDimitry Andric if (CountersSize > 0) 647349cc55cSDimitry Andric mmapForContinuousMode(CurrentFileOffset, File); 648349cc55cSDimitry Andric 649349cc55cSDimitry Andric if (doMerging()) { 650fe6060f1SDimitry Andric lprofUnlockFileHandle(File); 651349cc55cSDimitry Andric fclose(File); 652fe6060f1SDimitry Andric } 653fe6060f1SDimitry Andric } 654480093f4SDimitry Andric 6550b57cec5SDimitry Andric static const char *DefaultProfileName = "default.profraw"; 6560b57cec5SDimitry Andric static void resetFilenameToDefault(void) { 6570b57cec5SDimitry Andric if (lprofCurFilename.FilenamePat && lprofCurFilename.OwnsFilenamePat) { 65806c3fb27SDimitry Andric #ifdef __GNUC__ 65906c3fb27SDimitry Andric #pragma GCC diagnostic push 66006c3fb27SDimitry Andric #pragma GCC diagnostic ignored "-Wcast-qual" 66106c3fb27SDimitry Andric #endif 6620b57cec5SDimitry Andric free((void *)lprofCurFilename.FilenamePat); 66306c3fb27SDimitry Andric #ifdef __GNUC__ 66406c3fb27SDimitry Andric #pragma GCC diagnostic pop 66506c3fb27SDimitry Andric #endif 6660b57cec5SDimitry Andric } 6670b57cec5SDimitry Andric memset(&lprofCurFilename, 0, sizeof(lprofCurFilename)); 6680b57cec5SDimitry Andric lprofCurFilename.FilenamePat = DefaultProfileName; 6690b57cec5SDimitry Andric lprofCurFilename.PNS = PNS_default; 6700b57cec5SDimitry Andric } 6710b57cec5SDimitry Andric 672480093f4SDimitry Andric static unsigned getMergePoolSize(const char *FilenamePat, int *I) { 673480093f4SDimitry Andric unsigned J = 0, Num = 0; 674480093f4SDimitry Andric for (;; ++J) { 675480093f4SDimitry Andric char C = FilenamePat[*I + J]; 676480093f4SDimitry Andric if (C == 'm') { 677480093f4SDimitry Andric *I += J; 678480093f4SDimitry Andric return Num ? Num : 1; 679480093f4SDimitry Andric } 680480093f4SDimitry Andric if (C < '0' || C > '9') 681480093f4SDimitry Andric break; 682480093f4SDimitry Andric Num = Num * 10 + C - '0'; 683480093f4SDimitry Andric 684480093f4SDimitry Andric /* If FilenamePat[*I+J] is between '0' and '9', the next byte is guaranteed 6850b57cec5SDimitry Andric * to be in-bound as the string is null terminated. */ 686480093f4SDimitry Andric } 687480093f4SDimitry Andric return 0; 6880b57cec5SDimitry Andric } 6890b57cec5SDimitry Andric 690fe6060f1SDimitry Andric /* Assert that Idx does index past a string null terminator. Return the 691fe6060f1SDimitry Andric * result of the check. */ 692fe6060f1SDimitry Andric static int checkBounds(int Idx, int Strlen) { 693fe6060f1SDimitry Andric assert(Idx <= Strlen && "Indexing past string null terminator"); 694fe6060f1SDimitry Andric return Idx <= Strlen; 695fe6060f1SDimitry Andric } 696fe6060f1SDimitry Andric 6970b57cec5SDimitry Andric /* Parses the pattern string \p FilenamePat and stores the result to 6980b57cec5SDimitry Andric * lprofcurFilename structure. */ 6990b57cec5SDimitry Andric static int parseFilenamePattern(const char *FilenamePat, 7000b57cec5SDimitry Andric unsigned CopyFilenamePat) { 7010b57cec5SDimitry Andric int NumPids = 0, NumHosts = 0, I; 7020b57cec5SDimitry Andric char *PidChars = &lprofCurFilename.PidChars[0]; 7030b57cec5SDimitry Andric char *Hostname = &lprofCurFilename.Hostname[0]; 7040b57cec5SDimitry Andric int MergingEnabled = 0; 705fe6060f1SDimitry Andric int FilenamePatLen = strlen(FilenamePat); 7060b57cec5SDimitry Andric 70706c3fb27SDimitry Andric #ifdef __GNUC__ 70806c3fb27SDimitry Andric #pragma GCC diagnostic push 70906c3fb27SDimitry Andric #pragma GCC diagnostic ignored "-Wcast-qual" 71006c3fb27SDimitry Andric #endif 7110b57cec5SDimitry Andric /* Clean up cached prefix and filename. */ 7120b57cec5SDimitry Andric if (lprofCurFilename.ProfilePathPrefix) 7130b57cec5SDimitry Andric free((void *)lprofCurFilename.ProfilePathPrefix); 7140b57cec5SDimitry Andric 7150b57cec5SDimitry Andric if (lprofCurFilename.FilenamePat && lprofCurFilename.OwnsFilenamePat) { 7160b57cec5SDimitry Andric free((void *)lprofCurFilename.FilenamePat); 7170b57cec5SDimitry Andric } 71806c3fb27SDimitry Andric #ifdef __GNUC__ 71906c3fb27SDimitry Andric #pragma GCC diagnostic pop 72006c3fb27SDimitry Andric #endif 7210b57cec5SDimitry Andric 7220b57cec5SDimitry Andric memset(&lprofCurFilename, 0, sizeof(lprofCurFilename)); 7230b57cec5SDimitry Andric 7240b57cec5SDimitry Andric if (!CopyFilenamePat) 7250b57cec5SDimitry Andric lprofCurFilename.FilenamePat = FilenamePat; 7260b57cec5SDimitry Andric else { 7270b57cec5SDimitry Andric lprofCurFilename.FilenamePat = strdup(FilenamePat); 7280b57cec5SDimitry Andric lprofCurFilename.OwnsFilenamePat = 1; 7290b57cec5SDimitry Andric } 7300b57cec5SDimitry Andric /* Check the filename for "%p", which indicates a pid-substitution. */ 731fe6060f1SDimitry Andric for (I = 0; checkBounds(I, FilenamePatLen) && FilenamePat[I]; ++I) { 7320b57cec5SDimitry Andric if (FilenamePat[I] == '%') { 733fe6060f1SDimitry Andric ++I; /* Advance to the next character. */ 734fe6060f1SDimitry Andric if (!checkBounds(I, FilenamePatLen)) 735fe6060f1SDimitry Andric break; 736fe6060f1SDimitry Andric if (FilenamePat[I] == 'p') { 7370b57cec5SDimitry Andric if (!NumPids++) { 7380b57cec5SDimitry Andric if (snprintf(PidChars, MAX_PID_SIZE, "%ld", (long)getpid()) <= 0) { 7390b57cec5SDimitry Andric PROF_WARN("Unable to get pid for filename pattern %s. Using the " 7400b57cec5SDimitry Andric "default name.", 7410b57cec5SDimitry Andric FilenamePat); 7420b57cec5SDimitry Andric return -1; 7430b57cec5SDimitry Andric } 7440b57cec5SDimitry Andric } 7450b57cec5SDimitry Andric } else if (FilenamePat[I] == 'h') { 7460b57cec5SDimitry Andric if (!NumHosts++) 7470b57cec5SDimitry Andric if (COMPILER_RT_GETHOSTNAME(Hostname, COMPILER_RT_MAX_HOSTLEN)) { 7480b57cec5SDimitry Andric PROF_WARN("Unable to get hostname for filename pattern %s. Using " 7490b57cec5SDimitry Andric "the default name.", 7500b57cec5SDimitry Andric FilenamePat); 7510b57cec5SDimitry Andric return -1; 7520b57cec5SDimitry Andric } 753e8d8bef9SDimitry Andric } else if (FilenamePat[I] == 't') { 754e8d8bef9SDimitry Andric lprofCurFilename.TmpDir = getenv("TMPDIR"); 755e8d8bef9SDimitry Andric if (!lprofCurFilename.TmpDir) { 756e8d8bef9SDimitry Andric PROF_WARN("Unable to get the TMPDIR environment variable, referenced " 757e8d8bef9SDimitry Andric "in %s. Using the default path.", 758e8d8bef9SDimitry Andric FilenamePat); 759e8d8bef9SDimitry Andric return -1; 760e8d8bef9SDimitry Andric } 761480093f4SDimitry Andric } else if (FilenamePat[I] == 'c') { 762480093f4SDimitry Andric if (__llvm_profile_is_continuous_mode_enabled()) { 763480093f4SDimitry Andric PROF_WARN("%%c specifier can only be specified once in %s.\n", 764480093f4SDimitry Andric FilenamePat); 765480093f4SDimitry Andric return -1; 766480093f4SDimitry Andric } 767fe6060f1SDimitry Andric #if defined(__APPLE__) || defined(__ELF__) || defined(_WIN32) 768e8d8bef9SDimitry Andric __llvm_profile_set_page_size(getpagesize()); 769480093f4SDimitry Andric __llvm_profile_enable_continuous_mode(); 770fe6060f1SDimitry Andric #else 771fe6060f1SDimitry Andric PROF_WARN("%s", "Continous mode is currently only supported for Mach-O," 772fe6060f1SDimitry Andric " ELF and COFF formats."); 773fe6060f1SDimitry Andric return -1; 774fe6060f1SDimitry Andric #endif 775480093f4SDimitry Andric } else { 776480093f4SDimitry Andric unsigned MergePoolSize = getMergePoolSize(FilenamePat, &I); 777480093f4SDimitry Andric if (!MergePoolSize) 778480093f4SDimitry Andric continue; 7790b57cec5SDimitry Andric if (MergingEnabled) { 7800b57cec5SDimitry Andric PROF_WARN("%%m specifier can only be specified once in %s.\n", 7810b57cec5SDimitry Andric FilenamePat); 7820b57cec5SDimitry Andric return -1; 7830b57cec5SDimitry Andric } 7840b57cec5SDimitry Andric MergingEnabled = 1; 785480093f4SDimitry Andric lprofCurFilename.MergePoolSize = MergePoolSize; 7860b57cec5SDimitry Andric } 7870b57cec5SDimitry Andric } 788fe6060f1SDimitry Andric } 7890b57cec5SDimitry Andric 7900b57cec5SDimitry Andric lprofCurFilename.NumPids = NumPids; 7910b57cec5SDimitry Andric lprofCurFilename.NumHosts = NumHosts; 7920b57cec5SDimitry Andric return 0; 7930b57cec5SDimitry Andric } 7940b57cec5SDimitry Andric 7950b57cec5SDimitry Andric static void parseAndSetFilename(const char *FilenamePat, 7960b57cec5SDimitry Andric ProfileNameSpecifier PNS, 7970b57cec5SDimitry Andric unsigned CopyFilenamePat) { 7980b57cec5SDimitry Andric 7990b57cec5SDimitry Andric const char *OldFilenamePat = lprofCurFilename.FilenamePat; 8000b57cec5SDimitry Andric ProfileNameSpecifier OldPNS = lprofCurFilename.PNS; 8010b57cec5SDimitry Andric 802480093f4SDimitry Andric /* The old profile name specifier takes precedence over the old one. */ 8030b57cec5SDimitry Andric if (PNS < OldPNS) 8040b57cec5SDimitry Andric return; 8050b57cec5SDimitry Andric 8060b57cec5SDimitry Andric if (!FilenamePat) 8070b57cec5SDimitry Andric FilenamePat = DefaultProfileName; 8080b57cec5SDimitry Andric 8090b57cec5SDimitry Andric if (OldFilenamePat && !strcmp(OldFilenamePat, FilenamePat)) { 8100b57cec5SDimitry Andric lprofCurFilename.PNS = PNS; 8110b57cec5SDimitry Andric return; 8120b57cec5SDimitry Andric } 8130b57cec5SDimitry Andric 8140b57cec5SDimitry Andric /* When PNS >= OldPNS, the last one wins. */ 8150b57cec5SDimitry Andric if (!FilenamePat || parseFilenamePattern(FilenamePat, CopyFilenamePat)) 8160b57cec5SDimitry Andric resetFilenameToDefault(); 8170b57cec5SDimitry Andric lprofCurFilename.PNS = PNS; 8180b57cec5SDimitry Andric 8190b57cec5SDimitry Andric if (!OldFilenamePat) { 8200b57cec5SDimitry Andric if (getenv("LLVM_PROFILE_VERBOSE")) 8210b57cec5SDimitry Andric PROF_NOTE("Set profile file path to \"%s\" via %s.\n", 8220b57cec5SDimitry Andric lprofCurFilename.FilenamePat, getPNSStr(PNS)); 8230b57cec5SDimitry Andric } else { 8240b57cec5SDimitry Andric if (getenv("LLVM_PROFILE_VERBOSE")) 8250b57cec5SDimitry Andric PROF_NOTE("Override old profile path \"%s\" via %s to \"%s\" via %s.\n", 8260b57cec5SDimitry Andric OldFilenamePat, getPNSStr(OldPNS), lprofCurFilename.FilenamePat, 8270b57cec5SDimitry Andric getPNSStr(PNS)); 8280b57cec5SDimitry Andric } 8290b57cec5SDimitry Andric 8300b57cec5SDimitry Andric truncateCurrentFile(); 831fe6060f1SDimitry Andric if (__llvm_profile_is_continuous_mode_enabled()) 832480093f4SDimitry Andric initializeProfileForContinuousMode(); 8330b57cec5SDimitry Andric } 8340b57cec5SDimitry Andric 8350b57cec5SDimitry Andric /* Return buffer length that is required to store the current profile 8360b57cec5SDimitry Andric * filename with PID and hostname substitutions. */ 837480093f4SDimitry Andric /* The length to hold uint64_t followed by 3 digits pool id including '_' */ 8380b57cec5SDimitry Andric #define SIGLEN 24 83981ad6265SDimitry Andric static int getCurFilenameLength(void) { 8400b57cec5SDimitry Andric int Len; 8410b57cec5SDimitry Andric if (!lprofCurFilename.FilenamePat || !lprofCurFilename.FilenamePat[0]) 8420b57cec5SDimitry Andric return 0; 8430b57cec5SDimitry Andric 8440b57cec5SDimitry Andric if (!(lprofCurFilename.NumPids || lprofCurFilename.NumHosts || 845e8d8bef9SDimitry Andric lprofCurFilename.TmpDir || lprofCurFilename.MergePoolSize)) 8460b57cec5SDimitry Andric return strlen(lprofCurFilename.FilenamePat); 8470b57cec5SDimitry Andric 8480b57cec5SDimitry Andric Len = strlen(lprofCurFilename.FilenamePat) + 8490b57cec5SDimitry Andric lprofCurFilename.NumPids * (strlen(lprofCurFilename.PidChars) - 2) + 850e8d8bef9SDimitry Andric lprofCurFilename.NumHosts * (strlen(lprofCurFilename.Hostname) - 2) + 851e8d8bef9SDimitry Andric (lprofCurFilename.TmpDir ? (strlen(lprofCurFilename.TmpDir) - 1) : 0); 8520b57cec5SDimitry Andric if (lprofCurFilename.MergePoolSize) 8530b57cec5SDimitry Andric Len += SIGLEN; 8540b57cec5SDimitry Andric return Len; 8550b57cec5SDimitry Andric } 8560b57cec5SDimitry Andric 8570b57cec5SDimitry Andric /* Return the pointer to the current profile file name (after substituting 8580b57cec5SDimitry Andric * PIDs and Hostnames in filename pattern. \p FilenameBuf is the buffer 8590b57cec5SDimitry Andric * to store the resulting filename. If no substitution is needed, the 8600b57cec5SDimitry Andric * current filename pattern string is directly returned, unless ForceUseBuf 8610b57cec5SDimitry Andric * is enabled. */ 8620b57cec5SDimitry Andric static const char *getCurFilename(char *FilenameBuf, int ForceUseBuf) { 863e8d8bef9SDimitry Andric int I, J, PidLength, HostNameLength, TmpDirLength, FilenamePatLength; 8640b57cec5SDimitry Andric const char *FilenamePat = lprofCurFilename.FilenamePat; 8650b57cec5SDimitry Andric 8660b57cec5SDimitry Andric if (!lprofCurFilename.FilenamePat || !lprofCurFilename.FilenamePat[0]) 8670b57cec5SDimitry Andric return 0; 8680b57cec5SDimitry Andric 8690b57cec5SDimitry Andric if (!(lprofCurFilename.NumPids || lprofCurFilename.NumHosts || 870e8d8bef9SDimitry Andric lprofCurFilename.TmpDir || lprofCurFilename.MergePoolSize || 871480093f4SDimitry Andric __llvm_profile_is_continuous_mode_enabled())) { 8720b57cec5SDimitry Andric if (!ForceUseBuf) 8730b57cec5SDimitry Andric return lprofCurFilename.FilenamePat; 8740b57cec5SDimitry Andric 8750b57cec5SDimitry Andric FilenamePatLength = strlen(lprofCurFilename.FilenamePat); 8760b57cec5SDimitry Andric memcpy(FilenameBuf, lprofCurFilename.FilenamePat, FilenamePatLength); 8770b57cec5SDimitry Andric FilenameBuf[FilenamePatLength] = '\0'; 8780b57cec5SDimitry Andric return FilenameBuf; 8790b57cec5SDimitry Andric } 8800b57cec5SDimitry Andric 8810b57cec5SDimitry Andric PidLength = strlen(lprofCurFilename.PidChars); 8820b57cec5SDimitry Andric HostNameLength = strlen(lprofCurFilename.Hostname); 883e8d8bef9SDimitry Andric TmpDirLength = lprofCurFilename.TmpDir ? strlen(lprofCurFilename.TmpDir) : 0; 8840b57cec5SDimitry Andric /* Construct the new filename. */ 8850b57cec5SDimitry Andric for (I = 0, J = 0; FilenamePat[I]; ++I) 8860b57cec5SDimitry Andric if (FilenamePat[I] == '%') { 8870b57cec5SDimitry Andric if (FilenamePat[++I] == 'p') { 8880b57cec5SDimitry Andric memcpy(FilenameBuf + J, lprofCurFilename.PidChars, PidLength); 8890b57cec5SDimitry Andric J += PidLength; 8900b57cec5SDimitry Andric } else if (FilenamePat[I] == 'h') { 8910b57cec5SDimitry Andric memcpy(FilenameBuf + J, lprofCurFilename.Hostname, HostNameLength); 8920b57cec5SDimitry Andric J += HostNameLength; 893e8d8bef9SDimitry Andric } else if (FilenamePat[I] == 't') { 894e8d8bef9SDimitry Andric memcpy(FilenameBuf + J, lprofCurFilename.TmpDir, TmpDirLength); 895e8d8bef9SDimitry Andric FilenameBuf[J + TmpDirLength] = DIR_SEPARATOR; 896e8d8bef9SDimitry Andric J += TmpDirLength + 1; 897480093f4SDimitry Andric } else { 898480093f4SDimitry Andric if (!getMergePoolSize(FilenamePat, &I)) 899480093f4SDimitry Andric continue; 900480093f4SDimitry Andric char LoadModuleSignature[SIGLEN + 1]; 9010b57cec5SDimitry Andric int S; 9020b57cec5SDimitry Andric int ProfilePoolId = getpid() % lprofCurFilename.MergePoolSize; 903480093f4SDimitry Andric S = snprintf(LoadModuleSignature, SIGLEN + 1, "%" PRIu64 "_%d", 9040b57cec5SDimitry Andric lprofGetLoadModuleSignature(), ProfilePoolId); 9050b57cec5SDimitry Andric if (S == -1 || S > SIGLEN) 9060b57cec5SDimitry Andric S = SIGLEN; 9070b57cec5SDimitry Andric memcpy(FilenameBuf + J, LoadModuleSignature, S); 9080b57cec5SDimitry Andric J += S; 9090b57cec5SDimitry Andric } 9100b57cec5SDimitry Andric /* Drop any unknown substitutions. */ 9110b57cec5SDimitry Andric } else 9120b57cec5SDimitry Andric FilenameBuf[J++] = FilenamePat[I]; 9130b57cec5SDimitry Andric FilenameBuf[J] = 0; 9140b57cec5SDimitry Andric 9150b57cec5SDimitry Andric return FilenameBuf; 9160b57cec5SDimitry Andric } 9170b57cec5SDimitry Andric 9180b57cec5SDimitry Andric /* Returns the pointer to the environment variable 9190b57cec5SDimitry Andric * string. Returns null if the env var is not set. */ 9200b57cec5SDimitry Andric static const char *getFilenamePatFromEnv(void) { 9210b57cec5SDimitry Andric const char *Filename = getenv("LLVM_PROFILE_FILE"); 9220b57cec5SDimitry Andric if (!Filename || !Filename[0]) 9230b57cec5SDimitry Andric return 0; 9240b57cec5SDimitry Andric return Filename; 9250b57cec5SDimitry Andric } 9260b57cec5SDimitry Andric 9270b57cec5SDimitry Andric COMPILER_RT_VISIBILITY 9280b57cec5SDimitry Andric const char *__llvm_profile_get_path_prefix(void) { 9290b57cec5SDimitry Andric int Length; 9300b57cec5SDimitry Andric char *FilenameBuf, *Prefix; 9310b57cec5SDimitry Andric const char *Filename, *PrefixEnd; 9320b57cec5SDimitry Andric 9330b57cec5SDimitry Andric if (lprofCurFilename.ProfilePathPrefix) 9340b57cec5SDimitry Andric return lprofCurFilename.ProfilePathPrefix; 9350b57cec5SDimitry Andric 9360b57cec5SDimitry Andric Length = getCurFilenameLength(); 9370b57cec5SDimitry Andric FilenameBuf = (char *)COMPILER_RT_ALLOCA(Length + 1); 9380b57cec5SDimitry Andric Filename = getCurFilename(FilenameBuf, 0); 9390b57cec5SDimitry Andric if (!Filename) 9400b57cec5SDimitry Andric return "\0"; 9410b57cec5SDimitry Andric 9420b57cec5SDimitry Andric PrefixEnd = lprofFindLastDirSeparator(Filename); 9430b57cec5SDimitry Andric if (!PrefixEnd) 9440b57cec5SDimitry Andric return "\0"; 9450b57cec5SDimitry Andric 9460b57cec5SDimitry Andric Length = PrefixEnd - Filename + 1; 9470b57cec5SDimitry Andric Prefix = (char *)malloc(Length + 1); 9480b57cec5SDimitry Andric if (!Prefix) { 9490b57cec5SDimitry Andric PROF_ERR("Failed to %s\n", "allocate memory."); 9500b57cec5SDimitry Andric return "\0"; 9510b57cec5SDimitry Andric } 9520b57cec5SDimitry Andric memcpy(Prefix, Filename, Length); 9530b57cec5SDimitry Andric Prefix[Length] = '\0'; 9540b57cec5SDimitry Andric lprofCurFilename.ProfilePathPrefix = Prefix; 9550b57cec5SDimitry Andric return Prefix; 9560b57cec5SDimitry Andric } 9570b57cec5SDimitry Andric 9580b57cec5SDimitry Andric COMPILER_RT_VISIBILITY 9590b57cec5SDimitry Andric const char *__llvm_profile_get_filename(void) { 9600b57cec5SDimitry Andric int Length; 9610b57cec5SDimitry Andric char *FilenameBuf; 9620b57cec5SDimitry Andric const char *Filename; 9630b57cec5SDimitry Andric 9640b57cec5SDimitry Andric Length = getCurFilenameLength(); 9650b57cec5SDimitry Andric FilenameBuf = (char *)malloc(Length + 1); 9660b57cec5SDimitry Andric if (!FilenameBuf) { 9670b57cec5SDimitry Andric PROF_ERR("Failed to %s\n", "allocate memory."); 9680b57cec5SDimitry Andric return "\0"; 9690b57cec5SDimitry Andric } 9700b57cec5SDimitry Andric Filename = getCurFilename(FilenameBuf, 1); 9710b57cec5SDimitry Andric if (!Filename) 9720b57cec5SDimitry Andric return "\0"; 9730b57cec5SDimitry Andric 9740b57cec5SDimitry Andric return FilenameBuf; 9750b57cec5SDimitry Andric } 9760b57cec5SDimitry Andric 9775ffd83dbSDimitry Andric /* This API initializes the file handling, both user specified 9780b57cec5SDimitry Andric * profile path via -fprofile-instr-generate= and LLVM_PROFILE_FILE 9795ffd83dbSDimitry Andric * environment variable can override this default value. 9805ffd83dbSDimitry Andric */ 9810b57cec5SDimitry Andric COMPILER_RT_VISIBILITY 9820b57cec5SDimitry Andric void __llvm_profile_initialize_file(void) { 9830b57cec5SDimitry Andric const char *EnvFilenamePat; 9840b57cec5SDimitry Andric const char *SelectedPat = NULL; 9850b57cec5SDimitry Andric ProfileNameSpecifier PNS = PNS_unknown; 9860b57cec5SDimitry Andric int hasCommandLineOverrider = (INSTR_PROF_PROFILE_NAME_VAR[0] != 0); 9870b57cec5SDimitry Andric 9880b57cec5SDimitry Andric EnvFilenamePat = getFilenamePatFromEnv(); 9890b57cec5SDimitry Andric if (EnvFilenamePat) { 9900b57cec5SDimitry Andric /* Pass CopyFilenamePat = 1, to ensure that the filename would be valid 9910b57cec5SDimitry Andric at the moment when __llvm_profile_write_file() gets executed. */ 9920b57cec5SDimitry Andric parseAndSetFilename(EnvFilenamePat, PNS_environment, 1); 9930b57cec5SDimitry Andric return; 9940b57cec5SDimitry Andric } else if (hasCommandLineOverrider) { 9950b57cec5SDimitry Andric SelectedPat = INSTR_PROF_PROFILE_NAME_VAR; 9960b57cec5SDimitry Andric PNS = PNS_command_line; 9970b57cec5SDimitry Andric } else { 9980b57cec5SDimitry Andric SelectedPat = NULL; 9990b57cec5SDimitry Andric PNS = PNS_default; 10000b57cec5SDimitry Andric } 10010b57cec5SDimitry Andric 10020b57cec5SDimitry Andric parseAndSetFilename(SelectedPat, PNS, 0); 10030b57cec5SDimitry Andric } 10040b57cec5SDimitry Andric 10055ffd83dbSDimitry Andric /* This method is invoked by the runtime initialization hook 10065ffd83dbSDimitry Andric * InstrProfilingRuntime.o if it is linked in. 10075ffd83dbSDimitry Andric */ 10085ffd83dbSDimitry Andric COMPILER_RT_VISIBILITY 10095ffd83dbSDimitry Andric void __llvm_profile_initialize(void) { 10105ffd83dbSDimitry Andric __llvm_profile_initialize_file(); 10115ffd83dbSDimitry Andric if (!__llvm_profile_is_continuous_mode_enabled()) 10125ffd83dbSDimitry Andric __llvm_profile_register_write_file_atexit(); 10135ffd83dbSDimitry Andric } 10145ffd83dbSDimitry Andric 10150b57cec5SDimitry Andric /* This API is directly called by the user application code. It has the 10160b57cec5SDimitry Andric * highest precedence compared with LLVM_PROFILE_FILE environment variable 10170b57cec5SDimitry Andric * and command line option -fprofile-instr-generate=<profile_name>. 10180b57cec5SDimitry Andric */ 10190b57cec5SDimitry Andric COMPILER_RT_VISIBILITY 10200b57cec5SDimitry Andric void __llvm_profile_set_filename(const char *FilenamePat) { 1021480093f4SDimitry Andric if (__llvm_profile_is_continuous_mode_enabled()) 1022480093f4SDimitry Andric return; 10230b57cec5SDimitry Andric parseAndSetFilename(FilenamePat, PNS_runtime_api, 1); 10240b57cec5SDimitry Andric } 10250b57cec5SDimitry Andric 10260b57cec5SDimitry Andric /* The public API for writing profile data into the file with name 10270b57cec5SDimitry Andric * set by previous calls to __llvm_profile_set_filename or 10280b57cec5SDimitry Andric * __llvm_profile_override_default_filename or 10290b57cec5SDimitry Andric * __llvm_profile_initialize_file. */ 10300b57cec5SDimitry Andric COMPILER_RT_VISIBILITY 10310b57cec5SDimitry Andric int __llvm_profile_write_file(void) { 10320b57cec5SDimitry Andric int rc, Length; 10330b57cec5SDimitry Andric const char *Filename; 10340b57cec5SDimitry Andric char *FilenameBuf; 10350b57cec5SDimitry Andric int PDeathSig = 0; 10360b57cec5SDimitry Andric 1037480093f4SDimitry Andric if (lprofProfileDumped() || __llvm_profile_is_continuous_mode_enabled()) { 10380b57cec5SDimitry Andric PROF_NOTE("Profile data not written to file: %s.\n", "already written"); 10390b57cec5SDimitry Andric return 0; 10400b57cec5SDimitry Andric } 10410b57cec5SDimitry Andric 10420b57cec5SDimitry Andric Length = getCurFilenameLength(); 10430b57cec5SDimitry Andric FilenameBuf = (char *)COMPILER_RT_ALLOCA(Length + 1); 10440b57cec5SDimitry Andric Filename = getCurFilename(FilenameBuf, 0); 10450b57cec5SDimitry Andric 10460b57cec5SDimitry Andric /* Check the filename. */ 10470b57cec5SDimitry Andric if (!Filename) { 10480b57cec5SDimitry Andric PROF_ERR("Failed to write file : %s\n", "Filename not set"); 10490b57cec5SDimitry Andric return -1; 10500b57cec5SDimitry Andric } 10510b57cec5SDimitry Andric 10520b57cec5SDimitry Andric /* Check if there is llvm/runtime version mismatch. */ 10530b57cec5SDimitry Andric if (GET_VERSION(__llvm_profile_get_version()) != INSTR_PROF_RAW_VERSION) { 10540b57cec5SDimitry Andric PROF_ERR("Runtime and instrumentation version mismatch : " 10550b57cec5SDimitry Andric "expected %d, but get %d\n", 10560b57cec5SDimitry Andric INSTR_PROF_RAW_VERSION, 10570b57cec5SDimitry Andric (int)GET_VERSION(__llvm_profile_get_version())); 10580b57cec5SDimitry Andric return -1; 10590b57cec5SDimitry Andric } 10600b57cec5SDimitry Andric 10610b57cec5SDimitry Andric // Temporarily suspend getting SIGKILL when the parent exits. 10620b57cec5SDimitry Andric PDeathSig = lprofSuspendSigKill(); 10630b57cec5SDimitry Andric 10640b57cec5SDimitry Andric /* Write profile data to the file. */ 10650b57cec5SDimitry Andric rc = writeFile(Filename); 10660b57cec5SDimitry Andric if (rc) 10670b57cec5SDimitry Andric PROF_ERR("Failed to write file \"%s\": %s\n", Filename, strerror(errno)); 10680b57cec5SDimitry Andric 10690b57cec5SDimitry Andric // Restore SIGKILL. 10700b57cec5SDimitry Andric if (PDeathSig == 1) 10710b57cec5SDimitry Andric lprofRestoreSigKill(); 10720b57cec5SDimitry Andric 10730b57cec5SDimitry Andric return rc; 10740b57cec5SDimitry Andric } 10750b57cec5SDimitry Andric 10760b57cec5SDimitry Andric COMPILER_RT_VISIBILITY 10770b57cec5SDimitry Andric int __llvm_profile_dump(void) { 10780b57cec5SDimitry Andric if (!doMerging()) 10790b57cec5SDimitry Andric PROF_WARN("Later invocation of __llvm_profile_dump can lead to clobbering " 10800b57cec5SDimitry Andric " of previously dumped profile data : %s. Either use %%m " 10810b57cec5SDimitry Andric "in profile name or change profile name before dumping.\n", 10820b57cec5SDimitry Andric "online profile merging is not on"); 10830b57cec5SDimitry Andric int rc = __llvm_profile_write_file(); 10845ffd83dbSDimitry Andric lprofSetProfileDumped(1); 10850b57cec5SDimitry Andric return rc; 10860b57cec5SDimitry Andric } 10870b57cec5SDimitry Andric 10880b57cec5SDimitry Andric /* Order file data will be saved in a file with suffx .order. */ 10890b57cec5SDimitry Andric static const char *OrderFileSuffix = ".order"; 10900b57cec5SDimitry Andric 10910b57cec5SDimitry Andric COMPILER_RT_VISIBILITY 10920b57cec5SDimitry Andric int __llvm_orderfile_write_file(void) { 10930b57cec5SDimitry Andric int rc, Length, LengthBeforeAppend, SuffixLength; 10940b57cec5SDimitry Andric const char *Filename; 10950b57cec5SDimitry Andric char *FilenameBuf; 10960b57cec5SDimitry Andric int PDeathSig = 0; 10970b57cec5SDimitry Andric 10980b57cec5SDimitry Andric SuffixLength = strlen(OrderFileSuffix); 10990b57cec5SDimitry Andric Length = getCurFilenameLength() + SuffixLength; 11000b57cec5SDimitry Andric FilenameBuf = (char *)COMPILER_RT_ALLOCA(Length + 1); 11010b57cec5SDimitry Andric Filename = getCurFilename(FilenameBuf, 1); 11020b57cec5SDimitry Andric 11030b57cec5SDimitry Andric /* Check the filename. */ 11040b57cec5SDimitry Andric if (!Filename) { 11050b57cec5SDimitry Andric PROF_ERR("Failed to write file : %s\n", "Filename not set"); 11060b57cec5SDimitry Andric return -1; 11070b57cec5SDimitry Andric } 11080b57cec5SDimitry Andric 11090b57cec5SDimitry Andric /* Append order file suffix */ 11100b57cec5SDimitry Andric LengthBeforeAppend = strlen(Filename); 11110b57cec5SDimitry Andric memcpy(FilenameBuf + LengthBeforeAppend, OrderFileSuffix, SuffixLength); 11120b57cec5SDimitry Andric FilenameBuf[LengthBeforeAppend + SuffixLength] = '\0'; 11130b57cec5SDimitry Andric 11140b57cec5SDimitry Andric /* Check if there is llvm/runtime version mismatch. */ 11150b57cec5SDimitry Andric if (GET_VERSION(__llvm_profile_get_version()) != INSTR_PROF_RAW_VERSION) { 11160b57cec5SDimitry Andric PROF_ERR("Runtime and instrumentation version mismatch : " 11170b57cec5SDimitry Andric "expected %d, but get %d\n", 11180b57cec5SDimitry Andric INSTR_PROF_RAW_VERSION, 11190b57cec5SDimitry Andric (int)GET_VERSION(__llvm_profile_get_version())); 11200b57cec5SDimitry Andric return -1; 11210b57cec5SDimitry Andric } 11220b57cec5SDimitry Andric 11230b57cec5SDimitry Andric // Temporarily suspend getting SIGKILL when the parent exits. 11240b57cec5SDimitry Andric PDeathSig = lprofSuspendSigKill(); 11250b57cec5SDimitry Andric 11260b57cec5SDimitry Andric /* Write order data to the file. */ 11270b57cec5SDimitry Andric rc = writeOrderFile(Filename); 11280b57cec5SDimitry Andric if (rc) 11290b57cec5SDimitry Andric PROF_ERR("Failed to write file \"%s\": %s\n", Filename, strerror(errno)); 11300b57cec5SDimitry Andric 11310b57cec5SDimitry Andric // Restore SIGKILL. 11320b57cec5SDimitry Andric if (PDeathSig == 1) 11330b57cec5SDimitry Andric lprofRestoreSigKill(); 11340b57cec5SDimitry Andric 11350b57cec5SDimitry Andric return rc; 11360b57cec5SDimitry Andric } 11370b57cec5SDimitry Andric 11380b57cec5SDimitry Andric COMPILER_RT_VISIBILITY 11390b57cec5SDimitry Andric int __llvm_orderfile_dump(void) { 11400b57cec5SDimitry Andric int rc = __llvm_orderfile_write_file(); 11410b57cec5SDimitry Andric return rc; 11420b57cec5SDimitry Andric } 11430b57cec5SDimitry Andric 11440b57cec5SDimitry Andric static void writeFileWithoutReturn(void) { __llvm_profile_write_file(); } 11450b57cec5SDimitry Andric 11460b57cec5SDimitry Andric COMPILER_RT_VISIBILITY 11470b57cec5SDimitry Andric int __llvm_profile_register_write_file_atexit(void) { 11480b57cec5SDimitry Andric static int HasBeenRegistered = 0; 11490b57cec5SDimitry Andric 11500b57cec5SDimitry Andric if (HasBeenRegistered) 11510b57cec5SDimitry Andric return 0; 11520b57cec5SDimitry Andric 11530b57cec5SDimitry Andric lprofSetupValueProfiler(); 11540b57cec5SDimitry Andric 11550b57cec5SDimitry Andric HasBeenRegistered = 1; 11560b57cec5SDimitry Andric return atexit(writeFileWithoutReturn); 11570b57cec5SDimitry Andric } 11580b57cec5SDimitry Andric 1159349cc55cSDimitry Andric COMPILER_RT_VISIBILITY int __llvm_profile_set_file_object(FILE *File, 1160349cc55cSDimitry Andric int EnableMerge) { 1161349cc55cSDimitry Andric if (__llvm_profile_is_continuous_mode_enabled()) { 1162349cc55cSDimitry Andric if (!EnableMerge) { 1163349cc55cSDimitry Andric PROF_WARN("__llvm_profile_set_file_object(fd=%d) not supported in " 1164349cc55cSDimitry Andric "continuous sync mode when merging is disabled\n", 1165349cc55cSDimitry Andric fileno(File)); 1166349cc55cSDimitry Andric return 1; 1167349cc55cSDimitry Andric } 1168349cc55cSDimitry Andric if (lprofLockFileHandle(File) != 0) { 1169349cc55cSDimitry Andric PROF_WARN("Data may be corrupted during profile merging : %s\n", 1170349cc55cSDimitry Andric "Fail to obtain file lock due to system limit."); 1171349cc55cSDimitry Andric } 1172349cc55cSDimitry Andric uint64_t ProfileFileSize = 0; 1173349cc55cSDimitry Andric if (getProfileFileSizeForMerging(File, &ProfileFileSize) == -1) { 1174349cc55cSDimitry Andric lprofUnlockFileHandle(File); 1175349cc55cSDimitry Andric return 1; 1176349cc55cSDimitry Andric } 1177349cc55cSDimitry Andric if (ProfileFileSize == 0) { 1178349cc55cSDimitry Andric FreeHook = &free; 1179349cc55cSDimitry Andric setupIOBuffer(); 1180349cc55cSDimitry Andric ProfDataWriter fileWriter; 1181349cc55cSDimitry Andric initFileWriter(&fileWriter, File); 1182349cc55cSDimitry Andric if (lprofWriteData(&fileWriter, 0, 0)) { 1183349cc55cSDimitry Andric lprofUnlockFileHandle(File); 1184349cc55cSDimitry Andric PROF_ERR("Failed to write file \"%d\": %s\n", fileno(File), 1185349cc55cSDimitry Andric strerror(errno)); 1186349cc55cSDimitry Andric return 1; 1187349cc55cSDimitry Andric } 1188349cc55cSDimitry Andric fflush(File); 1189349cc55cSDimitry Andric } else { 1190349cc55cSDimitry Andric /* The merged profile has a non-zero length. Check that it is compatible 1191349cc55cSDimitry Andric * with the data in this process. */ 1192349cc55cSDimitry Andric char *ProfileBuffer; 1193349cc55cSDimitry Andric if (mmapProfileForMerging(File, ProfileFileSize, &ProfileBuffer) == -1) { 1194349cc55cSDimitry Andric lprofUnlockFileHandle(File); 1195349cc55cSDimitry Andric return 1; 1196349cc55cSDimitry Andric } 1197349cc55cSDimitry Andric (void)munmap(ProfileBuffer, ProfileFileSize); 1198349cc55cSDimitry Andric } 1199349cc55cSDimitry Andric mmapForContinuousMode(0, File); 1200349cc55cSDimitry Andric lprofUnlockFileHandle(File); 1201349cc55cSDimitry Andric } else { 1202349cc55cSDimitry Andric setProfileFile(File); 1203349cc55cSDimitry Andric setProfileMergeRequested(EnableMerge); 1204349cc55cSDimitry Andric } 1205349cc55cSDimitry Andric return 0; 1206349cc55cSDimitry Andric } 1207349cc55cSDimitry Andric 12080b57cec5SDimitry Andric #endif 1209