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 =
111         __llvm_profile_get_num_padding_bytes(CountersSize);
112     *PaddingBytesAfterNames = __llvm_profile_get_num_padding_bytes(NamesSize);
113     return;
114   }
115 
116   // In continuous mode, the file offsets for headers and for the start of
117   // counter sections need to be page-aligned.
118   *PaddingBytesBeforeCounters =
119       calculateBytesNeededToPageAlign(sizeof(__llvm_profile_header) + DataSize);
120   *PaddingBytesAfterCounters = calculateBytesNeededToPageAlign(CountersSize);
121   *PaddingBytesAfterNames = calculateBytesNeededToPageAlign(NamesSize);
122 }
123 
124 COMPILER_RT_VISIBILITY
125 uint64_t __llvm_profile_get_size_for_buffer_internal(
126     const __llvm_profile_data *DataBegin, const __llvm_profile_data *DataEnd,
127     const char *CountersBegin, const char *CountersEnd, const char *NamesBegin,
128     const char *NamesEnd) {
129   /* Match logic in __llvm_profile_write_buffer(). */
130   const uint64_t NamesSize = (NamesEnd - NamesBegin) * sizeof(char);
131   uint64_t DataSize = __llvm_profile_get_data_size(DataBegin, DataEnd);
132   uint64_t CountersSize =
133       __llvm_profile_get_counters_size(CountersBegin, CountersEnd);
134 
135   /* Determine how much padding is needed before/after the counters and after
136    * the names. */
137   uint64_t PaddingBytesBeforeCounters, PaddingBytesAfterCounters,
138       PaddingBytesAfterNames;
139   __llvm_profile_get_padding_sizes_for_counters(
140       DataSize, CountersSize, NamesSize, &PaddingBytesBeforeCounters,
141       &PaddingBytesAfterCounters, &PaddingBytesAfterNames);
142 
143   return sizeof(__llvm_profile_header) + __llvm_write_binary_ids(NULL) +
144          DataSize + PaddingBytesBeforeCounters + CountersSize +
145          PaddingBytesAfterCounters + NamesSize + PaddingBytesAfterNames;
146 }
147 
148 COMPILER_RT_VISIBILITY
149 void initBufferWriter(ProfDataWriter *BufferWriter, char *Buffer) {
150   BufferWriter->Write = lprofBufferWriter;
151   BufferWriter->WriterCtx = Buffer;
152 }
153 
154 COMPILER_RT_VISIBILITY int __llvm_profile_write_buffer(char *Buffer) {
155   ProfDataWriter BufferWriter;
156   initBufferWriter(&BufferWriter, Buffer);
157   return lprofWriteData(&BufferWriter, 0, 0);
158 }
159 
160 COMPILER_RT_VISIBILITY int __llvm_profile_write_buffer_internal(
161     char *Buffer, const __llvm_profile_data *DataBegin,
162     const __llvm_profile_data *DataEnd, const char *CountersBegin,
163     const char *CountersEnd, const char *NamesBegin, const char *NamesEnd) {
164   ProfDataWriter BufferWriter;
165   initBufferWriter(&BufferWriter, Buffer);
166   return lprofWriteDataImpl(&BufferWriter, DataBegin, DataEnd, CountersBegin,
167                             CountersEnd, 0, NamesBegin, NamesEnd, 0);
168 }
169