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