1 /*===- InstrProfiling.h- Support library for PGO instrumentation ----------===*\
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
7 \*===----------------------------------------------------------------------===*/
9 #ifndef PROFILE_INSTRPROFILING_INTERNALH_
10 #define PROFILE_INSTRPROFILING_INTERNALH_
14 #include "InstrProfiling.h"
17 * \brief Write instrumentation data to the given buffer, given explicit
18 * pointers to the live data in memory. This function is probably not what you
19 * want. Use __llvm_profile_get_size_for_buffer instead. Use this function if
20 * your program has a custom memory layout.
22 uint64_t __llvm_profile_get_size_for_buffer_internal(
23 const __llvm_profile_data *DataBegin, const __llvm_profile_data *DataEnd,
24 const uint64_t *CountersBegin, const uint64_t *CountersEnd,
25 const char *NamesBegin, const char *NamesEnd);
28 * \brief Write instrumentation data to the given buffer, given explicit
29 * pointers to the live data in memory. This function is probably not what you
30 * want. Use __llvm_profile_write_buffer instead. Use this function if your
31 * program has a custom memory layout.
33 * \pre \c Buffer is the start of a buffer at least as big as \a
34 * __llvm_profile_get_size_for_buffer_internal().
36 int __llvm_profile_write_buffer_internal(
37 char *Buffer, const __llvm_profile_data *DataBegin,
38 const __llvm_profile_data *DataEnd, const uint64_t *CountersBegin,
39 const uint64_t *CountersEnd, const char *NamesBegin, const char *NamesEnd);
42 * The data structure describing the data to be written by the
43 * low level writer callback function.
45 * If \ref ProfDataIOVec.Data is null, and \ref ProfDataIOVec.UseZeroPadding is
46 * 0, the write is skipped (the writer simply advances ElmSize*NumElm bytes).
48 * If \ref ProfDataIOVec.Data is null, and \ref ProfDataIOVec.UseZeroPadding is
49 * nonzero, ElmSize*NumElm zero bytes are written.
51 typedef struct ProfDataIOVec {
58 struct ProfDataWriter;
59 typedef uint32_t (*WriterCallback)(struct ProfDataWriter *This, ProfDataIOVec *,
62 typedef struct ProfDataWriter {
68 * The data structure for buffered IO of profile data.
70 typedef struct ProfBufferIO {
71 ProfDataWriter *FileWriter;
72 uint32_t OwnFileWriter;
73 /* The start of the buffer. */
75 /* Total size of the buffer. */
77 /* Current byte offset from the start of the buffer. */
81 /* The creator interface used by testing. */
82 ProfBufferIO *lprofCreateBufferIOInternal(void *File, uint32_t BufferSz);
85 * This is the interface to create a handle for buffered IO.
87 ProfBufferIO *lprofCreateBufferIO(ProfDataWriter *FileWriter);
90 * The interface to destroy the bufferIO handle and reclaim
93 void lprofDeleteBufferIO(ProfBufferIO *BufferIO);
96 * This is the interface to write \c Data of \c Size bytes through
97 * \c BufferIO. Returns 0 if successful, otherwise return -1.
99 int lprofBufferIOWrite(ProfBufferIO *BufferIO, const uint8_t *Data,
102 * The interface to flush the remaining data in the buffer.
103 * through the low level writer callback.
105 int lprofBufferIOFlush(ProfBufferIO *BufferIO);
107 /* The low level interface to write data into a buffer. It is used as the
108 * callback by other high level writer methods such as buffered IO writer
109 * and profile data writer. */
110 uint32_t lprofBufferWriter(ProfDataWriter *This, ProfDataIOVec *IOVecs,
112 void initBufferWriter(ProfDataWriter *BufferWriter, char *Buffer);
114 struct ValueProfData;
115 struct ValueProfRecord;
116 struct InstrProfValueData;
117 struct ValueProfNode;
120 * The class that defines a set of methods to read value profile
121 * data for streaming/serialization from the instrumentation runtime.
123 typedef struct VPDataReaderType {
124 uint32_t (*InitRTRecord)(const __llvm_profile_data *Data,
125 uint8_t *SiteCountArray[]);
126 /* Function pointer to getValueProfRecordHeader method. */
127 uint32_t (*GetValueProfRecordHeaderSize)(uint32_t NumSites);
128 /* Function pointer to getFristValueProfRecord method. */
129 struct ValueProfRecord *(*GetFirstValueProfRecord)(struct ValueProfData *);
130 /* Return the number of value data for site \p Site. */
131 uint32_t (*GetNumValueDataForSite)(uint32_t VK, uint32_t Site);
132 /* Return the total size of the value profile data of the
133 * current function. */
134 uint32_t (*GetValueProfDataSize)(void);
136 * Read the next \p N value data for site \p Site and store the data
137 * in \p Dst. \p StartNode is the first value node to start with if
138 * it is not null. The function returns the pointer to the value
139 * node pointer to be used as the \p StartNode of the next batch reading.
140 * If there is nothing left, it returns NULL.
142 struct ValueProfNode *(*GetValueData)(uint32_t ValueKind, uint32_t Site,
143 struct InstrProfValueData *Dst,
144 struct ValueProfNode *StartNode,
148 /* Write profile data to destinitation. If SkipNameDataWrite is set to 1,
149 the name data is already in destintation, we just skip over it. */
150 int lprofWriteData(ProfDataWriter *Writer, VPDataReaderType *VPDataReader,
151 int SkipNameDataWrite);
152 int lprofWriteDataImpl(ProfDataWriter *Writer,
153 const __llvm_profile_data *DataBegin,
154 const __llvm_profile_data *DataEnd,
155 const uint64_t *CountersBegin,
156 const uint64_t *CountersEnd,
157 VPDataReaderType *VPDataReader, const char *NamesBegin,
158 const char *NamesEnd, int SkipNameDataWrite);
160 /* Merge value profile data pointed to by SrcValueProfData into
161 * in-memory profile counters pointed by to DstData. */
162 void lprofMergeValueProfData(struct ValueProfData *SrcValueProfData,
163 __llvm_profile_data *DstData);
165 VPDataReaderType *lprofGetVPDataReader();
167 /* Internal interface used by test to reset the max number of
168 * tracked values per value site to be \p MaxVals.
170 void lprofSetMaxValsPerSite(uint32_t MaxVals);
171 void lprofSetupValueProfiler();
173 /* Return the profile header 'signature' value associated with the current
174 * executable or shared library. The signature value can be used to for
175 * a profile name that is unique to this load module so that it does not
176 * collide with profiles from other binaries. It also allows shared libraries
177 * to dump merged profile data into its own profile file. */
178 uint64_t lprofGetLoadModuleSignature();
181 * Return non zero value if the profile data has already been
182 * dumped to the file.
184 unsigned lprofProfileDumped();
185 void lprofSetProfileDumped();
187 COMPILER_RT_VISIBILITY extern void (*FreeHook)(void *);
188 COMPILER_RT_VISIBILITY extern uint8_t *DynamicBufferIOBuffer;
189 COMPILER_RT_VISIBILITY extern uint32_t VPBufferSize;
190 COMPILER_RT_VISIBILITY extern uint32_t VPMaxNumValsPerSite;
191 /* Pointer to the start of static value counters to be allocted. */
192 COMPILER_RT_VISIBILITY extern ValueProfNode *CurrentVNode;
193 COMPILER_RT_VISIBILITY extern ValueProfNode *EndVNode;
194 extern void (*VPMergeHook)(struct ValueProfData *, __llvm_profile_data *);