contrib/compiler-rt/lib/profile/InstrProfilingInternal.h

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