1/*===- InstrProfiling.h- Support library for PGO instrumentation ----------===*\
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#ifndef PROFILE_INSTRPROFILING_INTERNALH_
10#define PROFILE_INSTRPROFILING_INTERNALH_
11
12#include <stddef.h>
13
14#include "InstrProfiling.h"
15
16/*!
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.
21 */
22uint64_t __llvm_profile_get_size_for_buffer_internal(
23    const __llvm_profile_data *DataBegin, const __llvm_profile_data *DataEnd,
24    const char *CountersBegin, const char *CountersEnd, const char *BitmapBegin,
25    const char *BitmapEnd, const char *NamesBegin, const char *NamesEnd);
26
27/*!
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.
32 *
33 * \pre \c Buffer is the start of a buffer at least as big as \a
34 * __llvm_profile_get_size_for_buffer_internal().
35 */
36int __llvm_profile_write_buffer_internal(
37    char *Buffer, const __llvm_profile_data *DataBegin,
38    const __llvm_profile_data *DataEnd, const char *CountersBegin,
39    const char *CountersEnd, const char *BitmapBegin, const char *BitmapEnd,
40    const char *NamesBegin, const char *NamesEnd);
41
42/*!
43 * The data structure describing the data to be written by the
44 * low level writer callback function.
45 *
46 * If \ref ProfDataIOVec.Data is null, and \ref ProfDataIOVec.UseZeroPadding is
47 * 0, the write is skipped (the writer simply advances ElmSize*NumElm bytes).
48 *
49 * If \ref ProfDataIOVec.Data is null, and \ref ProfDataIOVec.UseZeroPadding is
50 * nonzero, ElmSize*NumElm zero bytes are written.
51 */
52typedef struct ProfDataIOVec {
53  const void *Data;
54  size_t ElmSize;
55  size_t NumElm;
56  int UseZeroPadding;
57} ProfDataIOVec;
58
59struct ProfDataWriter;
60typedef uint32_t (*WriterCallback)(struct ProfDataWriter *This, ProfDataIOVec *,
61                                   uint32_t NumIOVecs);
62
63typedef struct ProfDataWriter {
64  WriterCallback Write;
65  void *WriterCtx;
66} ProfDataWriter;
67
68/*!
69 * The data structure for buffered IO of profile data.
70 */
71typedef struct ProfBufferIO {
72  ProfDataWriter *FileWriter;
73  uint32_t OwnFileWriter;
74  /* The start of the buffer. */
75  uint8_t *BufferStart;
76  /* Total size of the buffer. */
77  uint32_t BufferSz;
78  /* Current byte offset from the start of the buffer. */
79  uint32_t CurOffset;
80} ProfBufferIO;
81
82/* The creator interface used by testing.  */
83ProfBufferIO *lprofCreateBufferIOInternal(void *File, uint32_t BufferSz);
84
85/*!
86 * This is the interface to create a handle for buffered IO.
87 */
88ProfBufferIO *lprofCreateBufferIO(ProfDataWriter *FileWriter);
89
90/*!
91 * The interface to destroy the bufferIO handle and reclaim
92 * the memory.
93 */
94void lprofDeleteBufferIO(ProfBufferIO *BufferIO);
95
96/*!
97 * This is the interface to write \c Data of \c Size bytes through
98 * \c BufferIO. Returns 0 if successful, otherwise return -1.
99 */
100int lprofBufferIOWrite(ProfBufferIO *BufferIO, const uint8_t *Data,
101                       uint32_t Size);
102/*!
103 * The interface to flush the remaining data in the buffer.
104 * through the low level writer callback.
105 */
106int lprofBufferIOFlush(ProfBufferIO *BufferIO);
107
108/* The low level interface to write data into a buffer. It is used as the
109 * callback by other high level writer methods such as buffered IO writer
110 * and profile data writer.  */
111uint32_t lprofBufferWriter(ProfDataWriter *This, ProfDataIOVec *IOVecs,
112                           uint32_t NumIOVecs);
113void initBufferWriter(ProfDataWriter *BufferWriter, char *Buffer);
114
115struct ValueProfData;
116struct ValueProfRecord;
117struct InstrProfValueData;
118struct ValueProfNode;
119
120/*!
121 * The class that defines a set of methods to read value profile
122 * data for streaming/serialization from the instrumentation runtime.
123 */
124typedef struct VPDataReaderType {
125  uint32_t (*InitRTRecord)(const __llvm_profile_data *Data,
126                           uint8_t *SiteCountArray[]);
127  /* Function pointer to getValueProfRecordHeader method. */
128  uint32_t (*GetValueProfRecordHeaderSize)(uint32_t NumSites);
129  /* Function pointer to getFristValueProfRecord method. */
130  struct ValueProfRecord *(*GetFirstValueProfRecord)(struct ValueProfData *);
131  /* Return the number of value data for site \p Site.  */
132  uint32_t (*GetNumValueDataForSite)(uint32_t VK, uint32_t Site);
133  /* Return the total size of the value profile data of the
134   * current function.  */
135  uint32_t (*GetValueProfDataSize)(void);
136  /*!
137   * Read the next \p N value data for site \p Site and store the data
138   * in \p Dst. \p StartNode is the first value node to start with if
139   * it is not null. The function returns the pointer to the value
140   * node pointer to be used as the \p StartNode of the next batch reading.
141   * If there is nothing left, it returns NULL.
142   */
143  struct ValueProfNode *(*GetValueData)(uint32_t ValueKind, uint32_t Site,
144                                        struct InstrProfValueData *Dst,
145                                        struct ValueProfNode *StartNode,
146                                        uint32_t N);
147} VPDataReaderType;
148
149/* Write profile data to destination. If SkipNameDataWrite is set to 1,
150   the name data is already in destination, we just skip over it. */
151int lprofWriteData(ProfDataWriter *Writer, VPDataReaderType *VPDataReader,
152                   int SkipNameDataWrite);
153int lprofWriteDataImpl(ProfDataWriter *Writer,
154                       const __llvm_profile_data *DataBegin,
155                       const __llvm_profile_data *DataEnd,
156                       const char *CountersBegin, const char *CountersEnd,
157                       const char *BitmapBegin, const char *BitmapEnd,
158                       VPDataReaderType *VPDataReader, const char *NamesBegin,
159                       const char *NamesEnd, int SkipNameDataWrite);
160
161/* Merge value profile data pointed to by SrcValueProfData into
162 * in-memory profile counters pointed by to DstData.  */
163void lprofMergeValueProfData(struct ValueProfData *SrcValueProfData,
164                             __llvm_profile_data *DstData);
165
166VPDataReaderType *lprofGetVPDataReader();
167
168/* Internal interface used by test to reset the max number of
169 * tracked values per value site to be \p MaxVals.
170 */
171void lprofSetMaxValsPerSite(uint32_t MaxVals);
172void lprofSetupValueProfiler();
173
174/* Return the profile header 'signature' value associated with the current
175 * executable or shared library. The signature value can be used to for
176 * a profile name that is unique to this load module so that it does not
177 * collide with profiles from other binaries. It also allows shared libraries
178 * to dump merged profile data into its own profile file. */
179uint64_t lprofGetLoadModuleSignature();
180
181/*
182 * Return non zero value if the profile data has already been
183 * dumped to the file.
184 */
185unsigned lprofProfileDumped(void);
186void lprofSetProfileDumped(unsigned);
187
188COMPILER_RT_VISIBILITY extern void (*FreeHook)(void *);
189COMPILER_RT_VISIBILITY extern uint8_t *DynamicBufferIOBuffer;
190COMPILER_RT_VISIBILITY extern uint32_t VPBufferSize;
191COMPILER_RT_VISIBILITY extern uint32_t VPMaxNumValsPerSite;
192/* Pointer to the start of static value counters to be allocted. */
193COMPILER_RT_VISIBILITY extern ValueProfNode *CurrentVNode;
194COMPILER_RT_VISIBILITY extern ValueProfNode *EndVNode;
195extern void (*VPMergeHook)(struct ValueProfData *, __llvm_profile_data *);
196
197/*
198 * Write binary ids into profiles if writer is given.
199 * Return -1 if an error occurs, otherwise, return total size of binary ids.
200 */
201int __llvm_write_binary_ids(ProfDataWriter *Writer);
202
203/*
204 * Write binary id length and then its data, because binary id does not
205 * have a fixed length.
206 */
207int lprofWriteOneBinaryId(ProfDataWriter *Writer, uint64_t BinaryIdLen,
208                          const uint8_t *BinaryIdData,
209                          uint64_t BinaryIdPadding);
210
211#endif
212