1 /*===- InstrProfilingBuffer.c - Write instrumentation to a memory buffer --===*\ 2 |* 3 |* Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 |* See https://llvm.org/LICENSE.txt for license information. 5 |* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 |* 7 \*===----------------------------------------------------------------------===*/ 8 9 // Note: This is linked into the Darwin kernel, and must remain compatible 10 // with freestanding compilation. See `darwin_add_builtin_libraries`. 11 12 #include "InstrProfiling.h" 13 #include "InstrProfilingInternal.h" 14 #include "InstrProfilingPort.h" 15 16 /* When continuous mode is enabled (%c), this parameter is set to 1. 17 * 18 * This parameter is defined here in InstrProfilingBuffer.o, instead of in 19 * InstrProfilingFile.o, to sequester all libc-dependent code in 20 * InstrProfilingFile.o. The test `instrprof-without-libc` will break if this 21 * layering is violated. */ 22 static int ContinuouslySyncProfile = 0; 23 24 /* The system page size. Only valid when non-zero. If 0, the page size is 25 * unavailable. */ 26 static unsigned PageSize = 0; 27 28 COMPILER_RT_VISIBILITY int __llvm_profile_is_continuous_mode_enabled(void) { 29 return ContinuouslySyncProfile && PageSize; 30 } 31 32 COMPILER_RT_VISIBILITY void __llvm_profile_enable_continuous_mode(void) { 33 ContinuouslySyncProfile = 1; 34 } 35 36 COMPILER_RT_VISIBILITY void __llvm_profile_set_page_size(unsigned PS) { 37 PageSize = PS; 38 } 39 40 COMPILER_RT_VISIBILITY 41 uint64_t __llvm_profile_get_size_for_buffer(void) { 42 const __llvm_profile_data *DataBegin = __llvm_profile_begin_data(); 43 const __llvm_profile_data *DataEnd = __llvm_profile_end_data(); 44 const char *CountersBegin = __llvm_profile_begin_counters(); 45 const char *CountersEnd = __llvm_profile_end_counters(); 46 const char *NamesBegin = __llvm_profile_begin_names(); 47 const char *NamesEnd = __llvm_profile_end_names(); 48 49 return __llvm_profile_get_size_for_buffer_internal( 50 DataBegin, DataEnd, CountersBegin, CountersEnd, NamesBegin, NamesEnd); 51 } 52 53 COMPILER_RT_VISIBILITY 54 uint64_t __llvm_profile_get_num_data(const __llvm_profile_data *Begin, 55 const __llvm_profile_data *End) { 56 intptr_t BeginI = (intptr_t)Begin, EndI = (intptr_t)End; 57 return ((EndI + sizeof(__llvm_profile_data) - 1) - BeginI) / 58 sizeof(__llvm_profile_data); 59 } 60 61 COMPILER_RT_VISIBILITY 62 uint64_t __llvm_profile_get_data_size(const __llvm_profile_data *Begin, 63 const __llvm_profile_data *End) { 64 return __llvm_profile_get_num_data(Begin, End) * sizeof(__llvm_profile_data); 65 } 66 67 COMPILER_RT_VISIBILITY size_t __llvm_profile_counter_entry_size(void) { 68 if (__llvm_profile_get_version() & VARIANT_MASK_BYTE_COVERAGE) 69 return sizeof(uint8_t); 70 return sizeof(uint64_t); 71 } 72 73 COMPILER_RT_VISIBILITY 74 uint64_t __llvm_profile_get_num_counters(const char *Begin, const char *End) { 75 intptr_t BeginI = (intptr_t)Begin, EndI = (intptr_t)End; 76 return ((EndI + __llvm_profile_counter_entry_size() - 1) - BeginI) / 77 __llvm_profile_counter_entry_size(); 78 } 79 80 COMPILER_RT_VISIBILITY 81 uint64_t __llvm_profile_get_counters_size(const char *Begin, const char *End) { 82 return __llvm_profile_get_num_counters(Begin, End) * 83 __llvm_profile_counter_entry_size(); 84 } 85 86 /// Calculate the number of padding bytes needed to add to \p Offset in order 87 /// for (\p Offset + Padding) to be page-aligned. 88 static uint64_t calculateBytesNeededToPageAlign(uint64_t Offset) { 89 uint64_t OffsetModPage = Offset % PageSize; 90 if (OffsetModPage > 0) 91 return PageSize - OffsetModPage; 92 return 0; 93 } 94 95 static int needsCounterPadding(void) { 96 #if defined(__APPLE__) 97 return __llvm_profile_is_continuous_mode_enabled(); 98 #else 99 return 0; 100 #endif 101 } 102 103 COMPILER_RT_VISIBILITY 104 void __llvm_profile_get_padding_sizes_for_counters( 105 uint64_t DataSize, uint64_t CountersSize, uint64_t NamesSize, 106 uint64_t *PaddingBytesBeforeCounters, uint64_t *PaddingBytesAfterCounters, 107 uint64_t *PaddingBytesAfterNames) { 108 if (!needsCounterPadding()) { 109 *PaddingBytesBeforeCounters = 0; 110 *PaddingBytesAfterCounters = 0; 111 *PaddingBytesAfterNames = __llvm_profile_get_num_padding_bytes(NamesSize); 112 return; 113 } 114 115 // In continuous mode, the file offsets for headers and for the start of 116 // counter sections need to be page-aligned. 117 *PaddingBytesBeforeCounters = 118 calculateBytesNeededToPageAlign(sizeof(__llvm_profile_header) + DataSize); 119 *PaddingBytesAfterCounters = calculateBytesNeededToPageAlign(CountersSize); 120 *PaddingBytesAfterNames = calculateBytesNeededToPageAlign(NamesSize); 121 } 122 123 COMPILER_RT_VISIBILITY 124 uint64_t __llvm_profile_get_size_for_buffer_internal( 125 const __llvm_profile_data *DataBegin, const __llvm_profile_data *DataEnd, 126 const char *CountersBegin, const char *CountersEnd, const char *NamesBegin, 127 const char *NamesEnd) { 128 /* Match logic in __llvm_profile_write_buffer(). */ 129 const uint64_t NamesSize = (NamesEnd - NamesBegin) * sizeof(char); 130 uint64_t DataSize = __llvm_profile_get_data_size(DataBegin, DataEnd); 131 uint64_t CountersSize = 132 __llvm_profile_get_counters_size(CountersBegin, CountersEnd); 133 134 /* Determine how much padding is needed before/after the counters and after 135 * the names. */ 136 uint64_t PaddingBytesBeforeCounters, PaddingBytesAfterCounters, 137 PaddingBytesAfterNames; 138 __llvm_profile_get_padding_sizes_for_counters( 139 DataSize, CountersSize, NamesSize, &PaddingBytesBeforeCounters, 140 &PaddingBytesAfterCounters, &PaddingBytesAfterNames); 141 142 return sizeof(__llvm_profile_header) + __llvm_write_binary_ids(NULL) + 143 DataSize + PaddingBytesBeforeCounters + CountersSize + 144 PaddingBytesAfterCounters + NamesSize + PaddingBytesAfterNames; 145 } 146 147 COMPILER_RT_VISIBILITY 148 void initBufferWriter(ProfDataWriter *BufferWriter, char *Buffer) { 149 BufferWriter->Write = lprofBufferWriter; 150 BufferWriter->WriterCtx = Buffer; 151 } 152 153 COMPILER_RT_VISIBILITY int __llvm_profile_write_buffer(char *Buffer) { 154 ProfDataWriter BufferWriter; 155 initBufferWriter(&BufferWriter, Buffer); 156 return lprofWriteData(&BufferWriter, 0, 0); 157 } 158 159 COMPILER_RT_VISIBILITY int __llvm_profile_write_buffer_internal( 160 char *Buffer, const __llvm_profile_data *DataBegin, 161 const __llvm_profile_data *DataEnd, const char *CountersBegin, 162 const char *CountersEnd, const char *NamesBegin, const char *NamesEnd) { 163 ProfDataWriter BufferWriter; 164 initBufferWriter(&BufferWriter, Buffer); 165 return lprofWriteDataImpl(&BufferWriter, DataBegin, DataEnd, CountersBegin, 166 CountersEnd, 0, NamesBegin, NamesEnd, 0); 167 } 168