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   return sizeof(uint64_t);
69 }
70 
71 COMPILER_RT_VISIBILITY
72 uint64_t __llvm_profile_get_num_counters(const char *Begin, const char *End) {
73   intptr_t BeginI = (intptr_t)Begin, EndI = (intptr_t)End;
74   return ((EndI + __llvm_profile_counter_entry_size() - 1) - BeginI) /
75          __llvm_profile_counter_entry_size();
76 }
77 
78 COMPILER_RT_VISIBILITY
79 uint64_t __llvm_profile_get_counters_size(const char *Begin, const char *End) {
80   return __llvm_profile_get_num_counters(Begin, End) *
81          __llvm_profile_counter_entry_size();
82 }
83 
84 /// Calculate the number of padding bytes needed to add to \p Offset in order
85 /// for (\p Offset + Padding) to be page-aligned.
86 static uint64_t calculateBytesNeededToPageAlign(uint64_t Offset) {
87   uint64_t OffsetModPage = Offset % PageSize;
88   if (OffsetModPage > 0)
89     return PageSize - OffsetModPage;
90   return 0;
91 }
92 
93 static int needsCounterPadding(void) {
94 #if defined(__APPLE__)
95   return __llvm_profile_is_continuous_mode_enabled();
96 #else
97   return 0;
98 #endif
99 }
100 
101 COMPILER_RT_VISIBILITY
102 void __llvm_profile_get_padding_sizes_for_counters(
103     uint64_t DataSize, uint64_t CountersSize, uint64_t NamesSize,
104     uint64_t *PaddingBytesBeforeCounters, uint64_t *PaddingBytesAfterCounters,
105     uint64_t *PaddingBytesAfterNames) {
106   if (!needsCounterPadding()) {
107     *PaddingBytesBeforeCounters = 0;
108     *PaddingBytesAfterCounters = 0;
109     *PaddingBytesAfterNames = __llvm_profile_get_num_padding_bytes(NamesSize);
110     return;
111   }
112 
113   // In continuous mode, the file offsets for headers and for the start of
114   // counter sections need to be page-aligned.
115   *PaddingBytesBeforeCounters =
116       calculateBytesNeededToPageAlign(sizeof(__llvm_profile_header) + DataSize);
117   *PaddingBytesAfterCounters = calculateBytesNeededToPageAlign(CountersSize);
118   *PaddingBytesAfterNames = calculateBytesNeededToPageAlign(NamesSize);
119 }
120 
121 COMPILER_RT_VISIBILITY
122 uint64_t __llvm_profile_get_size_for_buffer_internal(
123     const __llvm_profile_data *DataBegin, const __llvm_profile_data *DataEnd,
124     const char *CountersBegin, const char *CountersEnd, const char *NamesBegin,
125     const char *NamesEnd) {
126   /* Match logic in __llvm_profile_write_buffer(). */
127   const uint64_t NamesSize = (NamesEnd - NamesBegin) * sizeof(char);
128   uint64_t DataSize = __llvm_profile_get_data_size(DataBegin, DataEnd);
129   uint64_t CountersSize =
130       __llvm_profile_get_counters_size(CountersBegin, CountersEnd);
131 
132   /* Determine how much padding is needed before/after the counters and after
133    * the names. */
134   uint64_t PaddingBytesBeforeCounters, PaddingBytesAfterCounters,
135       PaddingBytesAfterNames;
136   __llvm_profile_get_padding_sizes_for_counters(
137       DataSize, CountersSize, NamesSize, &PaddingBytesBeforeCounters,
138       &PaddingBytesAfterCounters, &PaddingBytesAfterNames);
139 
140   return sizeof(__llvm_profile_header) + __llvm_write_binary_ids(NULL) +
141          DataSize + PaddingBytesBeforeCounters + CountersSize +
142          PaddingBytesAfterCounters + NamesSize + PaddingBytesAfterNames;
143 }
144 
145 COMPILER_RT_VISIBILITY
146 void initBufferWriter(ProfDataWriter *BufferWriter, char *Buffer) {
147   BufferWriter->Write = lprofBufferWriter;
148   BufferWriter->WriterCtx = Buffer;
149 }
150 
151 COMPILER_RT_VISIBILITY int __llvm_profile_write_buffer(char *Buffer) {
152   ProfDataWriter BufferWriter;
153   initBufferWriter(&BufferWriter, Buffer);
154   return lprofWriteData(&BufferWriter, 0, 0);
155 }
156 
157 COMPILER_RT_VISIBILITY int __llvm_profile_write_buffer_internal(
158     char *Buffer, const __llvm_profile_data *DataBegin,
159     const __llvm_profile_data *DataEnd, const char *CountersBegin,
160     const char *CountersEnd, const char *NamesBegin, const char *NamesEnd) {
161   ProfDataWriter BufferWriter;
162   initBufferWriter(&BufferWriter, Buffer);
163   return lprofWriteDataImpl(&BufferWriter, DataBegin, DataEnd, CountersBegin,
164                             CountersEnd, 0, NamesBegin, NamesEnd, 0);
165 }
166