1 /*===- InstrProfilingWriter.c - Write instrumentation to a file or buffer -===*\
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 #include "InstrProfiling.h"
11 #include "InstrProfilingInternal.h"
12 #include <string.h>
13
14 #define INSTR_PROF_VALUE_PROF_DATA
15 #include "InstrProfData.inc"
16 void (*FreeHook)(void *) = NULL;
17 void* (*CallocHook)(size_t, size_t) = NULL;
18 uint32_t VPBufferSize = 0;
19
20 /* The buffer writer is reponsponsible in keeping writer state
21 * across the call.
22 */
llvmBufferWriter(ProfDataIOVec * IOVecs,uint32_t NumIOVecs,void ** WriterCtx)23 COMPILER_RT_VISIBILITY uint32_t llvmBufferWriter(ProfDataIOVec *IOVecs,
24 uint32_t NumIOVecs,
25 void **WriterCtx) {
26 uint32_t I;
27 char **Buffer = (char **)WriterCtx;
28 for (I = 0; I < NumIOVecs; I++) {
29 size_t Length = IOVecs[I].ElmSize * IOVecs[I].NumElm;
30 memcpy(*Buffer, IOVecs[I].Data, Length);
31 *Buffer += Length;
32 }
33 return 0;
34 }
35
llvmInitBufferIO(ProfBufferIO * BufferIO,WriterCallback FileWriter,void * File,uint8_t * Buffer,uint32_t BufferSz)36 static void llvmInitBufferIO(ProfBufferIO *BufferIO, WriterCallback FileWriter,
37 void *File, uint8_t *Buffer, uint32_t BufferSz) {
38 BufferIO->File = File;
39 BufferIO->FileWriter = FileWriter;
40 BufferIO->BufferStart = Buffer;
41 BufferIO->BufferSz = BufferSz;
42 BufferIO->CurOffset = 0;
43 }
44
45 COMPILER_RT_VISIBILITY ProfBufferIO *
llvmCreateBufferIO(WriterCallback FileWriter,void * File,uint32_t BufferSz)46 llvmCreateBufferIO(WriterCallback FileWriter, void *File, uint32_t BufferSz) {
47 ProfBufferIO *BufferIO = (ProfBufferIO *)CallocHook(1, sizeof(ProfBufferIO));
48 uint8_t *Buffer = (uint8_t *)CallocHook(1, BufferSz);
49 if (!Buffer) {
50 FreeHook(BufferIO);
51 return 0;
52 }
53 llvmInitBufferIO(BufferIO, FileWriter, File, Buffer, BufferSz);
54 return BufferIO;
55 }
56
llvmDeleteBufferIO(ProfBufferIO * BufferIO)57 COMPILER_RT_VISIBILITY void llvmDeleteBufferIO(ProfBufferIO *BufferIO) {
58 FreeHook(BufferIO->BufferStart);
59 FreeHook(BufferIO);
60 }
61
62 COMPILER_RT_VISIBILITY int
llvmBufferIOWrite(ProfBufferIO * BufferIO,const uint8_t * Data,uint32_t Size)63 llvmBufferIOWrite(ProfBufferIO *BufferIO, const uint8_t *Data, uint32_t Size) {
64 /* Buffer is not large enough, it is time to flush. */
65 if (Size + BufferIO->CurOffset > BufferIO->BufferSz) {
66 if (llvmBufferIOFlush(BufferIO) != 0)
67 return -1;
68 }
69 /* Special case, bypass the buffer completely. */
70 ProfDataIOVec IO[] = {{Data, sizeof(uint8_t), Size}};
71 if (Size > BufferIO->BufferSz) {
72 if (BufferIO->FileWriter(IO, 1, &BufferIO->File))
73 return -1;
74 } else {
75 /* Write the data to buffer */
76 uint8_t *Buffer = BufferIO->BufferStart + BufferIO->CurOffset;
77 llvmBufferWriter(IO, 1, (void **)&Buffer);
78 BufferIO->CurOffset = Buffer - BufferIO->BufferStart;
79 }
80 return 0;
81 }
82
llvmBufferIOFlush(ProfBufferIO * BufferIO)83 COMPILER_RT_VISIBILITY int llvmBufferIOFlush(ProfBufferIO *BufferIO) {
84 if (BufferIO->CurOffset) {
85 ProfDataIOVec IO[] = {
86 {BufferIO->BufferStart, sizeof(uint8_t), BufferIO->CurOffset}};
87 if (BufferIO->FileWriter(IO, 1, &BufferIO->File))
88 return -1;
89 BufferIO->CurOffset = 0;
90 }
91 return 0;
92 }
93
llvmWriteProfData(WriterCallback Writer,void * WriterCtx,ValueProfData ** ValueDataArray,const uint64_t ValueDataSize)94 COMPILER_RT_VISIBILITY int llvmWriteProfData(WriterCallback Writer,
95 void *WriterCtx,
96 ValueProfData **ValueDataArray,
97 const uint64_t ValueDataSize) {
98 /* Match logic in __llvm_profile_write_buffer(). */
99 const __llvm_profile_data *DataBegin = __llvm_profile_begin_data();
100 const __llvm_profile_data *DataEnd = __llvm_profile_end_data();
101 const uint64_t *CountersBegin = __llvm_profile_begin_counters();
102 const uint64_t *CountersEnd = __llvm_profile_end_counters();
103 const char *NamesBegin = __llvm_profile_begin_names();
104 const char *NamesEnd = __llvm_profile_end_names();
105 return llvmWriteProfDataImpl(Writer, WriterCtx, DataBegin, DataEnd,
106 CountersBegin, CountersEnd, ValueDataArray,
107 ValueDataSize, NamesBegin, NamesEnd);
108 }
109
110 #define VP_BUFFER_SIZE 8 * 1024
writeValueProfData(WriterCallback Writer,void * WriterCtx,ValueProfData ** ValueDataBegin,uint64_t NumVData)111 static int writeValueProfData(WriterCallback Writer, void *WriterCtx,
112 ValueProfData **ValueDataBegin,
113 uint64_t NumVData) {
114 ProfBufferIO *BufferIO;
115 uint32_t I = 0, BufferSz;
116
117 if (!ValueDataBegin)
118 return 0;
119
120 BufferSz = VPBufferSize ? VPBufferSize : VP_BUFFER_SIZE;
121 BufferIO = llvmCreateBufferIO(Writer, WriterCtx, BufferSz);
122
123 for (I = 0; I < NumVData; I++) {
124 ValueProfData *CurVData = ValueDataBegin[I];
125 if (!CurVData)
126 continue;
127 if (llvmBufferIOWrite(BufferIO, (const uint8_t *)CurVData,
128 CurVData->TotalSize) != 0)
129 return -1;
130 }
131
132 if (llvmBufferIOFlush(BufferIO) != 0)
133 return -1;
134 llvmDeleteBufferIO(BufferIO);
135
136 return 0;
137 }
138
llvmWriteProfDataImpl(WriterCallback Writer,void * WriterCtx,const __llvm_profile_data * DataBegin,const __llvm_profile_data * DataEnd,const uint64_t * CountersBegin,const uint64_t * CountersEnd,ValueProfData ** ValueDataBegin,const uint64_t ValueDataSize,const char * NamesBegin,const char * NamesEnd)139 COMPILER_RT_VISIBILITY int llvmWriteProfDataImpl(
140 WriterCallback Writer, void *WriterCtx,
141 const __llvm_profile_data *DataBegin, const __llvm_profile_data *DataEnd,
142 const uint64_t *CountersBegin, const uint64_t *CountersEnd,
143 ValueProfData **ValueDataBegin, const uint64_t ValueDataSize,
144 const char *NamesBegin, const char *NamesEnd) {
145
146 /* Calculate size of sections. */
147 const uint64_t DataSize = DataEnd - DataBegin;
148 const uint64_t CountersSize = CountersEnd - CountersBegin;
149 const uint64_t NamesSize = NamesEnd - NamesBegin;
150 const uint64_t Padding = __llvm_profile_get_num_padding_bytes(NamesSize);
151
152 /* Enough zeroes for padding. */
153 const char Zeroes[sizeof(uint64_t)] = {0};
154
155 /* Create the header. */
156 __llvm_profile_header Header;
157
158 if (!DataSize)
159 return 0;
160
161 /* Initialize header struture. */
162 #define INSTR_PROF_RAW_HEADER(Type, Name, Init) Header.Name = Init;
163 #include "InstrProfData.inc"
164
165 /* Write the data. */
166 ProfDataIOVec IOVec[] = {{&Header, sizeof(__llvm_profile_header), 1},
167 {DataBegin, sizeof(__llvm_profile_data), DataSize},
168 {CountersBegin, sizeof(uint64_t), CountersSize},
169 {NamesBegin, sizeof(uint8_t), NamesSize},
170 {Zeroes, sizeof(uint8_t), Padding}};
171 if (Writer(IOVec, sizeof(IOVec) / sizeof(*IOVec), &WriterCtx))
172 return -1;
173
174 return writeValueProfData(Writer, WriterCtx, ValueDataBegin, DataSize);
175 }
176