1 /*===-- PathProfiling.c - Support library for path profiling --------------===*\
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 |* This file implements the call back routines for the path profiling
11 |* instrumentation pass. This should be used with the -insert-path-profiling
12 |* LLVM pass.
13 |*
14 \*===----------------------------------------------------------------------===*/
15
16 #include "Profiling.h"
17 #include "llvm/Analysis/ProfileInfoTypes.h"
18 #include "llvm/Support/DataTypes.h"
19 #include <sys/types.h>
20 #if !defined(_MSC_VER) && !defined(__MINGW32__)
21 #include <unistd.h>
22 #else
23 #include <io.h>
24 #endif
25 #include <string.h>
26 #include <stdlib.h>
27 #include <stdio.h>
28
29 /* Must use __inline in Microsoft C */
30 #if defined(_MSC_VER)
31 #define inline __inline
32 #endif
33
34 /* note that this is used for functions with large path counts,
35 but it is unlikely those paths will ALL be executed */
36 #define ARBITRARY_HASH_BIN_COUNT 100
37
38 typedef struct pathHashEntry_s {
39 uint32_t pathNumber;
40 uint32_t pathCount;
41 struct pathHashEntry_s* next;
42 } pathHashEntry_t;
43
44 typedef struct pathHashTable_s {
45 pathHashEntry_t* hashBins[ARBITRARY_HASH_BIN_COUNT];
46 uint32_t pathCounts;
47 } pathHashTable_t;
48
49 typedef struct {
50 enum ProfilingStorageType type;
51 uint32_t size;
52 void* array;
53 } ftEntry_t;
54
55 /* pointer to the function table allocated in the instrumented program */
56 ftEntry_t* ft;
57 uint32_t ftSize;
58
59 /* write an array table to file */
writeArrayTable(uint32_t fNumber,ftEntry_t * ft,uint32_t * funcCount)60 void writeArrayTable(uint32_t fNumber, ftEntry_t* ft, uint32_t* funcCount) {
61 int outFile = getOutFile();
62 uint32_t arrayHeaderLocation = 0;
63 uint32_t arrayCurrentLocation = 0;
64 uint32_t arrayIterator = 0;
65 uint32_t functionUsed = 0;
66 uint32_t pathCounts = 0;
67
68 /* look through each entry in the array to determine whether the function
69 was executed at all */
70 for( arrayIterator = 0; arrayIterator < ft->size; arrayIterator++ ) {
71 uint32_t pc = ((uint32_t*)ft->array)[arrayIterator];
72
73 /* was this path executed? */
74 if( pc ) {
75 PathProfileTableEntry pte;
76 pte.pathNumber = arrayIterator;
77 pte.pathCounter = pc;
78 pathCounts++;
79
80 /* one-time initialization stuff */
81 if(!functionUsed) {
82 arrayHeaderLocation = lseek(outFile, 0, SEEK_CUR);
83 lseek(outFile, sizeof(PathProfileHeader), SEEK_CUR);
84 functionUsed = 1;
85 (*funcCount)++;
86 }
87
88 /* write path data */
89 if (write(outFile, &pte, sizeof(PathProfileTableEntry)) < 0) {
90 fprintf(stderr, "error: unable to write path entry to output file.\n");
91 return;
92 }
93 }
94 }
95
96 /* If this function was executed, write the header */
97 if( functionUsed ) {
98 PathProfileHeader fHeader;
99 fHeader.fnNumber = fNumber;
100 fHeader.numEntries = pathCounts;
101
102 arrayCurrentLocation = lseek(outFile, 0, SEEK_CUR);
103 lseek(outFile, arrayHeaderLocation, SEEK_SET);
104
105 if (write(outFile, &fHeader, sizeof(PathProfileHeader)) < 0) {
106 fprintf(stderr,
107 "error: unable to write function header to output file.\n");
108 return;
109 }
110
111 lseek(outFile, arrayCurrentLocation, SEEK_SET);
112 }
113 }
114
hash(uint32_t key)115 static inline uint32_t hash (uint32_t key) {
116 /* this may benefit from a proper hash function */
117 return key%ARBITRARY_HASH_BIN_COUNT;
118 }
119
120 /* output a specific function's hash table to the profile file */
writeHashTable(uint32_t functionNumber,pathHashTable_t * hashTable)121 void writeHashTable(uint32_t functionNumber, pathHashTable_t* hashTable) {
122 int outFile = getOutFile();
123 PathProfileHeader header;
124 uint32_t i;
125
126 header.fnNumber = functionNumber;
127 header.numEntries = hashTable->pathCounts;
128
129 if (write(outFile, &header, sizeof(PathProfileHeader)) < 0) {
130 fprintf(stderr, "error: unable to write function header to output file.\n");
131 return;
132 }
133
134 for (i = 0; i < ARBITRARY_HASH_BIN_COUNT; i++) {
135 pathHashEntry_t* hashEntry = hashTable->hashBins[i];
136
137 while (hashEntry) {
138 pathHashEntry_t* temp;
139
140 PathProfileTableEntry pte;
141 pte.pathNumber = hashEntry->pathNumber;
142 pte.pathCounter = hashEntry->pathCount;
143
144 if (write(outFile, &pte, sizeof(PathProfileTableEntry)) < 0) {
145 fprintf(stderr, "error: unable to write path entry to output file.\n");
146 return;
147 }
148
149 temp = hashEntry;
150 hashEntry = hashEntry->next;
151 free (temp);
152
153 }
154 }
155 }
156
157 /* Return a pointer to this path's specific path counter */
getPathCounter(uint32_t functionNumber,uint32_t pathNumber)158 static inline uint32_t* getPathCounter(uint32_t functionNumber,
159 uint32_t pathNumber) {
160 pathHashTable_t* hashTable;
161 pathHashEntry_t* hashEntry;
162 uint32_t index = hash(pathNumber);
163
164 if( ft[functionNumber-1].array == 0)
165 ft[functionNumber-1].array = calloc(sizeof(pathHashTable_t), 1);
166
167 hashTable = (pathHashTable_t*)((ftEntry_t*)ft)[functionNumber-1].array;
168 hashEntry = hashTable->hashBins[index];
169
170 while (hashEntry) {
171 if (hashEntry->pathNumber == pathNumber) {
172 return &hashEntry->pathCount;
173 }
174
175 hashEntry = hashEntry->next;
176 }
177
178 hashEntry = malloc(sizeof(pathHashEntry_t));
179 hashEntry->pathNumber = pathNumber;
180 hashEntry->pathCount = 0;
181 hashEntry->next = hashTable->hashBins[index];
182 hashTable->hashBins[index] = hashEntry;
183 hashTable->pathCounts++;
184 return &hashEntry->pathCount;
185 }
186
187 /* Increment a specific path's count */
llvm_increment_path_count(uint32_t functionNumber,uint32_t pathNumber)188 void llvm_increment_path_count (uint32_t functionNumber, uint32_t pathNumber) {
189 uint32_t* pathCounter = getPathCounter(functionNumber, pathNumber);
190 if( *pathCounter < 0xffffffff )
191 (*pathCounter)++;
192 }
193
194 /* Increment a specific path's count */
llvm_decrement_path_count(uint32_t functionNumber,uint32_t pathNumber)195 void llvm_decrement_path_count (uint32_t functionNumber, uint32_t pathNumber) {
196 uint32_t* pathCounter = getPathCounter(functionNumber, pathNumber);
197 (*pathCounter)--;
198 }
199
200 /*
201 * Writes out a path profile given a function table, in the following format.
202 *
203 *
204 * | <-- 32 bits --> |
205 * +-----------------+-----------------+
206 * 0x00 | profileType | functionCount |
207 * +-----------------+-----------------+
208 * 0x08 | functionNum | profileEntries | // function 1
209 * +-----------------+-----------------+
210 * 0x10 | pathNumber | pathCounter | // entry 1.1
211 * +-----------------+-----------------+
212 * 0x18 | pathNumber | pathCounter | // entry 1.2
213 * +-----------------+-----------------+
214 * ... | ... | ... | // entry 1.n
215 * +-----------------+-----------------+
216 * ... | functionNum | profileEntries | // function 2
217 * +-----------------+-----------------+
218 * ... | pathNumber | pathCounter | // entry 2.1
219 * +-----------------+-----------------+
220 * ... | pathNumber | pathCounter | // entry 2.2
221 * +-----------------+-----------------+
222 * ... | ... | ... | // entry 2.n
223 * +-----------------+-----------------+
224 *
225 */
pathProfAtExitHandler(void)226 static void pathProfAtExitHandler(void) {
227 int outFile = getOutFile();
228 uint32_t i;
229 uint32_t header[2] = { PathInfo, 0 };
230 uint32_t headerLocation;
231 uint32_t currentLocation;
232
233 /* skip over the header for now */
234 headerLocation = lseek(outFile, 0, SEEK_CUR);
235 lseek(outFile, 2*sizeof(uint32_t), SEEK_CUR);
236
237 /* Iterate through each function */
238 for( i = 0; i < ftSize; i++ ) {
239 if( ft[i].type == ProfilingArray ) {
240 writeArrayTable(i+1,&ft[i],header + 1);
241
242 } else if( ft[i].type == ProfilingHash ) {
243 /* If the hash exists, write it to file */
244 if( ft[i].array ) {
245 writeHashTable(i+1,ft[i].array);
246 header[1]++;
247 free(ft[i].array);
248 }
249 }
250 }
251
252 /* Setup and write the path profile header */
253 currentLocation = lseek(outFile, 0, SEEK_CUR);
254 lseek(outFile, headerLocation, SEEK_SET);
255
256 if (write(outFile, header, sizeof(header)) < 0) {
257 fprintf(stderr,
258 "error: unable to write path profile header to output file.\n");
259 return;
260 }
261
262 lseek(outFile, currentLocation, SEEK_SET);
263 }
264 /* llvm_start_path_profiling - This is the main entry point of the path
265 * profiling library. It is responsible for setting up the atexit handler.
266 */
llvm_start_path_profiling(int argc,const char ** argv,void * functionTable,uint32_t numElements)267 int llvm_start_path_profiling(int argc, const char** argv,
268 void* functionTable, uint32_t numElements) {
269 int Ret = save_arguments(argc, argv);
270 ft = functionTable;
271 ftSize = numElements;
272 atexit(pathProfAtExitHandler);
273
274 return Ret;
275 }
276