compiler-rt/lib/profile/InstrProfilingInternal.h

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