src/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 "InstrProfiling.h"
  14 #include "stddef.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 uint64_t *CountersBegin, const uint64_t *CountersEnd,
  25     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  */
  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);
  40
  41 /*!
  42  * The data structure describing the data to be written by the
  43  * low level writer callback function.
  44  */
  45 typedef struct ProfDataIOVec {
  46   const void *Data;
  47   size_t ElmSize;
  48   size_t NumElm;
  49 } ProfDataIOVec;
  50
  51 typedef uint32_t (*WriterCallback)(ProfDataIOVec *, uint32_t NumIOVecs,
  52                                    void **WriterCtx);
  53
  54 /*!
  55  * The data structure for buffered IO of profile data.
  56  */
  57 typedef struct ProfBufferIO {
  58   /* File handle.  */
  59   void *File;
  60   /* Low level IO callback. */
  61   WriterCallback FileWriter;
  62   /* The start of the buffer. */
  63   uint8_t *BufferStart;
  64   /* Total size of the buffer. */
  65   uint32_t BufferSz;
  66   /* Current byte offset from the start of the buffer. */
  67   uint32_t CurOffset;
  68 } ProfBufferIO;
  69
  70 /* The creator interface used by testing.  */
  71 ProfBufferIO *lprofCreateBufferIOInternal(void *File, uint32_t BufferSz);
  72
  73 /*!
  74  * This is the interface to create a handle for buffered IO.
  75  */
  76 ProfBufferIO *lprofCreateBufferIO(WriterCallback FileWriter, void *File);
  77
  78 /*!
  79  * The interface to destroy the bufferIO handle and reclaim
  80  * the memory.
  81  */
  82 void lprofDeleteBufferIO(ProfBufferIO *BufferIO);
  83
  84 /*!
  85  * This is the interface to write \c Data of \c Size bytes through
  86  * \c BufferIO. Returns 0 if successful, otherwise return -1.
  87  */
  88 int lprofBufferIOWrite(ProfBufferIO *BufferIO, const uint8_t *Data,
  89                        uint32_t Size);
  90 /*!
  91  * The interface to flush the remaining data in the buffer.
  92  * through the low level writer callback.
  93  */
  94 int lprofBufferIOFlush(ProfBufferIO *BufferIO);
  95
  96 /* The low level interface to write data into a buffer. It is used as the
  97  * callback by other high level writer methods such as buffered IO writer
  98  * and profile data writer.  */
  99 uint32_t lprofBufferWriter(ProfDataIOVec *IOVecs, uint32_t NumIOVecs,
 100                            void **WriterCtx);
 101
 102 struct ValueProfData;
 103 struct ValueProfRecord;
 104 struct InstrProfValueData;
 105 struct ValueProfNode;
 106
 107 /*!
 108  * The class that defines a set of methods to read value profile
 109  * data for streaming/serialization from the instrumentation runtime.
 110  */
 111 typedef struct VPDataReaderType {
 112   uint32_t (*InitRTRecord)(const __llvm_profile_data *Data,
 113                            uint8_t *SiteCountArray[]);
 114   /* Function pointer to getValueProfRecordHeader method. */
 115   uint32_t (*GetValueProfRecordHeaderSize)(uint32_t NumSites);
 116   /* Function pointer to getFristValueProfRecord method. */
 117   struct ValueProfRecord *(*GetFirstValueProfRecord)(struct ValueProfData *);
 118   /* Return the number of value data for site \p Site.  */
 119   uint32_t (*GetNumValueDataForSite)(uint32_t VK, uint32_t Site);
 120   /* Return the total size of the value profile data of the
 121    * current function.  */
 122   uint32_t (*GetValueProfDataSize)(void);
 123   /*!
 124    * Read the next \p N value data for site \p Site and store the data
 125    * in \p Dst. \p StartNode is the first value node to start with if
 126    * it is not null. The function returns the pointer to the value
 127    * node pointer to be used as the \p StartNode of the next batch reading.
 128    * If there is nothing left, it returns NULL.
 129    */
 130   struct ValueProfNode *(*GetValueData)(uint32_t ValueKind, uint32_t Site,
 131                                         struct InstrProfValueData *Dst,
 132                                         struct ValueProfNode *StartNode,
 133                                         uint32_t N);
 134 } VPDataReaderType;
 135
 136 int lprofWriteData(WriterCallback Writer, void *WriterCtx,
 137                    VPDataReaderType *VPDataReader);
 138 int lprofWriteDataImpl(WriterCallback Writer, void *WriterCtx,
 139                        const __llvm_profile_data *DataBegin,
 140                        const __llvm_profile_data *DataEnd,
 141                        const uint64_t *CountersBegin,
 142                        const uint64_t *CountersEnd,
 143                        VPDataReaderType *VPDataReader, const char *NamesBegin,
 144                        const char *NamesEnd);
 145
 146 /* Merge value profile data pointed to by SrcValueProfData into
 147  * in-memory profile counters pointed by to DstData.  */
 148 void lprofMergeValueProfData(struct ValueProfData *SrcValueProfData,
 149                              __llvm_profile_data *DstData);
 150
 151 VPDataReaderType *lprofGetVPDataReader();
 152
 153 /* Internal interface used by test to reset the max number of
 154  * tracked values per value site to be \p MaxVals.
 155  */
 156 void lprofSetMaxValsPerSite(uint32_t MaxVals);
 157 void lprofSetupValueProfiler();
 158
 159 /* Return the profile header 'signature' value associated with the current
 160  * executable or shared library. The signature value can be used to for
 161  * a profile name that is unique to this load module so that it does not
 162  * collide with profiles from other binaries. It also allows shared libraries
 163  * to dump merged profile data into its own profile file. */
 164 uint64_t lprofGetLoadModuleSignature();
 165
 166 /*
 167  * Return non zero value if the profile data has already been
 168  * dumped to the file.
 169  */
 170 unsigned lprofProfileDumped();
 171 void lprofSetProfileDumped();
 172
 173 COMPILER_RT_VISIBILITY extern void (*FreeHook)(void *);
 174 COMPILER_RT_VISIBILITY extern uint8_t *DynamicBufferIOBuffer;
 175 COMPILER_RT_VISIBILITY extern uint32_t VPBufferSize;
 176 COMPILER_RT_VISIBILITY extern uint32_t VPMaxNumValsPerSite;
 177 /* Pointer to the start of static value counters to be allocted. */
 178 COMPILER_RT_VISIBILITY extern ValueProfNode *CurrentVNode;
 179 COMPILER_RT_VISIBILITY extern ValueProfNode *EndVNode;
 180 extern void (*VPMergeHook)(struct ValueProfData *, __llvm_profile_data *);
 181
 182 #endif