Merge tag 'platform-drivers-x86-v5.1-1' of git://git.infradead.org/linux-platform...
[linux-2.6-microblaze.git] / kernel / gcov / gcc_3_4.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  *  This code provides functions to handle gcc's profiling data format
4  *  introduced with gcc 3.4. Future versions of gcc may change the gcov
5  *  format (as happened before), so all format-specific information needs
6  *  to be kept modular and easily exchangeable.
7  *
8  *  This file is based on gcc-internal definitions. Functions and data
9  *  structures are defined to be compatible with gcc counterparts.
10  *  For a better understanding, refer to gcc source: gcc/gcov-io.h.
11  *
12  *    Copyright IBM Corp. 2009
13  *    Author(s): Peter Oberparleiter <oberpar@linux.vnet.ibm.com>
14  *
15  *    Uses gcc-internal data definitions.
16  */
17
18 #include <linux/errno.h>
19 #include <linux/slab.h>
20 #include <linux/string.h>
21 #include <linux/seq_file.h>
22 #include <linux/vmalloc.h>
23 #include "gcov.h"
24
25 #define GCOV_COUNTERS           5
26
27 static struct gcov_info *gcov_info_head;
28
29 /**
30  * struct gcov_fn_info - profiling meta data per function
31  * @ident: object file-unique function identifier
32  * @checksum: function checksum
33  * @n_ctrs: number of values per counter type belonging to this function
34  *
35  * This data is generated by gcc during compilation and doesn't change
36  * at run-time.
37  */
38 struct gcov_fn_info {
39         unsigned int ident;
40         unsigned int checksum;
41         unsigned int n_ctrs[0];
42 };
43
44 /**
45  * struct gcov_ctr_info - profiling data per counter type
46  * @num: number of counter values for this type
47  * @values: array of counter values for this type
48  * @merge: merge function for counter values of this type (unused)
49  *
50  * This data is generated by gcc during compilation and doesn't change
51  * at run-time with the exception of the values array.
52  */
53 struct gcov_ctr_info {
54         unsigned int    num;
55         gcov_type       *values;
56         void            (*merge)(gcov_type *, unsigned int);
57 };
58
59 /**
60  * struct gcov_info - profiling data per object file
61  * @version: gcov version magic indicating the gcc version used for compilation
62  * @next: list head for a singly-linked list
63  * @stamp: time stamp
64  * @filename: name of the associated gcov data file
65  * @n_functions: number of instrumented functions
66  * @functions: function data
67  * @ctr_mask: mask specifying which counter types are active
68  * @counts: counter data per counter type
69  *
70  * This data is generated by gcc during compilation and doesn't change
71  * at run-time with the exception of the next pointer.
72  */
73 struct gcov_info {
74         unsigned int                    version;
75         struct gcov_info                *next;
76         unsigned int                    stamp;
77         const char                      *filename;
78         unsigned int                    n_functions;
79         const struct gcov_fn_info       *functions;
80         unsigned int                    ctr_mask;
81         struct gcov_ctr_info            counts[0];
82 };
83
84 /**
85  * gcov_info_filename - return info filename
86  * @info: profiling data set
87  */
88 const char *gcov_info_filename(struct gcov_info *info)
89 {
90         return info->filename;
91 }
92
93 /**
94  * gcov_info_version - return info version
95  * @info: profiling data set
96  */
97 unsigned int gcov_info_version(struct gcov_info *info)
98 {
99         return info->version;
100 }
101
102 /**
103  * gcov_info_next - return next profiling data set
104  * @info: profiling data set
105  *
106  * Returns next gcov_info following @info or first gcov_info in the chain if
107  * @info is %NULL.
108  */
109 struct gcov_info *gcov_info_next(struct gcov_info *info)
110 {
111         if (!info)
112                 return gcov_info_head;
113
114         return info->next;
115 }
116
117 /**
118  * gcov_info_link - link/add profiling data set to the list
119  * @info: profiling data set
120  */
121 void gcov_info_link(struct gcov_info *info)
122 {
123         info->next = gcov_info_head;
124         gcov_info_head = info;
125 }
126
127 /**
128  * gcov_info_unlink - unlink/remove profiling data set from the list
129  * @prev: previous profiling data set
130  * @info: profiling data set
131  */
132 void gcov_info_unlink(struct gcov_info *prev, struct gcov_info *info)
133 {
134         if (prev)
135                 prev->next = info->next;
136         else
137                 gcov_info_head = info->next;
138 }
139
140 /* Symbolic links to be created for each profiling data file. */
141 const struct gcov_link gcov_link[] = {
142         { OBJ_TREE, "gcno" },   /* Link to .gcno file in $(objtree). */
143         { 0, NULL},
144 };
145
146 /*
147  * Determine whether a counter is active. Based on gcc magic. Doesn't change
148  * at run-time.
149  */
150 static int counter_active(struct gcov_info *info, unsigned int type)
151 {
152         return (1 << type) & info->ctr_mask;
153 }
154
155 /* Determine number of active counters. Based on gcc magic. */
156 static unsigned int num_counter_active(struct gcov_info *info)
157 {
158         unsigned int i;
159         unsigned int result = 0;
160
161         for (i = 0; i < GCOV_COUNTERS; i++) {
162                 if (counter_active(info, i))
163                         result++;
164         }
165         return result;
166 }
167
168 /**
169  * gcov_info_reset - reset profiling data to zero
170  * @info: profiling data set
171  */
172 void gcov_info_reset(struct gcov_info *info)
173 {
174         unsigned int active = num_counter_active(info);
175         unsigned int i;
176
177         for (i = 0; i < active; i++) {
178                 memset(info->counts[i].values, 0,
179                        info->counts[i].num * sizeof(gcov_type));
180         }
181 }
182
183 /**
184  * gcov_info_is_compatible - check if profiling data can be added
185  * @info1: first profiling data set
186  * @info2: second profiling data set
187  *
188  * Returns non-zero if profiling data can be added, zero otherwise.
189  */
190 int gcov_info_is_compatible(struct gcov_info *info1, struct gcov_info *info2)
191 {
192         return (info1->stamp == info2->stamp);
193 }
194
195 /**
196  * gcov_info_add - add up profiling data
197  * @dest: profiling data set to which data is added
198  * @source: profiling data set which is added
199  *
200  * Adds profiling counts of @source to @dest.
201  */
202 void gcov_info_add(struct gcov_info *dest, struct gcov_info *source)
203 {
204         unsigned int i;
205         unsigned int j;
206
207         for (i = 0; i < num_counter_active(dest); i++) {
208                 for (j = 0; j < dest->counts[i].num; j++) {
209                         dest->counts[i].values[j] +=
210                                 source->counts[i].values[j];
211                 }
212         }
213 }
214
215 /* Get size of function info entry. Based on gcc magic. */
216 static size_t get_fn_size(struct gcov_info *info)
217 {
218         size_t size;
219
220         size = sizeof(struct gcov_fn_info) + num_counter_active(info) *
221                sizeof(unsigned int);
222         if (__alignof__(struct gcov_fn_info) > sizeof(unsigned int))
223                 size = ALIGN(size, __alignof__(struct gcov_fn_info));
224         return size;
225 }
226
227 /* Get address of function info entry. Based on gcc magic. */
228 static struct gcov_fn_info *get_fn_info(struct gcov_info *info, unsigned int fn)
229 {
230         return (struct gcov_fn_info *)
231                 ((char *) info->functions + fn * get_fn_size(info));
232 }
233
234 /**
235  * gcov_info_dup - duplicate profiling data set
236  * @info: profiling data set to duplicate
237  *
238  * Return newly allocated duplicate on success, %NULL on error.
239  */
240 struct gcov_info *gcov_info_dup(struct gcov_info *info)
241 {
242         struct gcov_info *dup;
243         unsigned int i;
244         unsigned int active;
245
246         /* Duplicate gcov_info. */
247         active = num_counter_active(info);
248         dup = kzalloc(struct_size(dup, counts, active), GFP_KERNEL);
249         if (!dup)
250                 return NULL;
251         dup->version            = info->version;
252         dup->stamp              = info->stamp;
253         dup->n_functions        = info->n_functions;
254         dup->ctr_mask           = info->ctr_mask;
255         /* Duplicate filename. */
256         dup->filename           = kstrdup(info->filename, GFP_KERNEL);
257         if (!dup->filename)
258                 goto err_free;
259         /* Duplicate table of functions. */
260         dup->functions = kmemdup(info->functions, info->n_functions *
261                                  get_fn_size(info), GFP_KERNEL);
262         if (!dup->functions)
263                 goto err_free;
264         /* Duplicate counter arrays. */
265         for (i = 0; i < active ; i++) {
266                 struct gcov_ctr_info *ctr = &info->counts[i];
267                 size_t size = ctr->num * sizeof(gcov_type);
268
269                 dup->counts[i].num = ctr->num;
270                 dup->counts[i].merge = ctr->merge;
271                 dup->counts[i].values = vmalloc(size);
272                 if (!dup->counts[i].values)
273                         goto err_free;
274                 memcpy(dup->counts[i].values, ctr->values, size);
275         }
276         return dup;
277
278 err_free:
279         gcov_info_free(dup);
280         return NULL;
281 }
282
283 /**
284  * gcov_info_free - release memory for profiling data set duplicate
285  * @info: profiling data set duplicate to free
286  */
287 void gcov_info_free(struct gcov_info *info)
288 {
289         unsigned int active = num_counter_active(info);
290         unsigned int i;
291
292         for (i = 0; i < active ; i++)
293                 vfree(info->counts[i].values);
294         kfree(info->functions);
295         kfree(info->filename);
296         kfree(info);
297 }
298
299 /**
300  * struct type_info - iterator helper array
301  * @ctr_type: counter type
302  * @offset: index of the first value of the current function for this type
303  *
304  * This array is needed to convert the in-memory data format into the in-file
305  * data format:
306  *
307  * In-memory:
308  *   for each counter type
309  *     for each function
310  *       values
311  *
312  * In-file:
313  *   for each function
314  *     for each counter type
315  *       values
316  *
317  * See gcc source gcc/gcov-io.h for more information on data organization.
318  */
319 struct type_info {
320         int ctr_type;
321         unsigned int offset;
322 };
323
324 /**
325  * struct gcov_iterator - specifies current file position in logical records
326  * @info: associated profiling data
327  * @record: record type
328  * @function: function number
329  * @type: counter type
330  * @count: index into values array
331  * @num_types: number of counter types
332  * @type_info: helper array to get values-array offset for current function
333  */
334 struct gcov_iterator {
335         struct gcov_info *info;
336
337         int record;
338         unsigned int function;
339         unsigned int type;
340         unsigned int count;
341
342         int num_types;
343         struct type_info type_info[0];
344 };
345
346 static struct gcov_fn_info *get_func(struct gcov_iterator *iter)
347 {
348         return get_fn_info(iter->info, iter->function);
349 }
350
351 static struct type_info *get_type(struct gcov_iterator *iter)
352 {
353         return &iter->type_info[iter->type];
354 }
355
356 /**
357  * gcov_iter_new - allocate and initialize profiling data iterator
358  * @info: profiling data set to be iterated
359  *
360  * Return file iterator on success, %NULL otherwise.
361  */
362 struct gcov_iterator *gcov_iter_new(struct gcov_info *info)
363 {
364         struct gcov_iterator *iter;
365
366         iter = kzalloc(struct_size(iter, type_info, num_counter_active(info)),
367                        GFP_KERNEL);
368         if (iter)
369                 iter->info = info;
370
371         return iter;
372 }
373
374 /**
375  * gcov_iter_free - release memory for iterator
376  * @iter: file iterator to free
377  */
378 void gcov_iter_free(struct gcov_iterator *iter)
379 {
380         kfree(iter);
381 }
382
383 /**
384  * gcov_iter_get_info - return profiling data set for given file iterator
385  * @iter: file iterator
386  */
387 struct gcov_info *gcov_iter_get_info(struct gcov_iterator *iter)
388 {
389         return iter->info;
390 }
391
392 /**
393  * gcov_iter_start - reset file iterator to starting position
394  * @iter: file iterator
395  */
396 void gcov_iter_start(struct gcov_iterator *iter)
397 {
398         int i;
399
400         iter->record = 0;
401         iter->function = 0;
402         iter->type = 0;
403         iter->count = 0;
404         iter->num_types = 0;
405         for (i = 0; i < GCOV_COUNTERS; i++) {
406                 if (counter_active(iter->info, i)) {
407                         iter->type_info[iter->num_types].ctr_type = i;
408                         iter->type_info[iter->num_types++].offset = 0;
409                 }
410         }
411 }
412
413 /* Mapping of logical record number to actual file content. */
414 #define RECORD_FILE_MAGIC       0
415 #define RECORD_GCOV_VERSION     1
416 #define RECORD_TIME_STAMP       2
417 #define RECORD_FUNCTION_TAG     3
418 #define RECORD_FUNCTON_TAG_LEN  4
419 #define RECORD_FUNCTION_IDENT   5
420 #define RECORD_FUNCTION_CHECK   6
421 #define RECORD_COUNT_TAG        7
422 #define RECORD_COUNT_LEN        8
423 #define RECORD_COUNT            9
424
425 /**
426  * gcov_iter_next - advance file iterator to next logical record
427  * @iter: file iterator
428  *
429  * Return zero if new position is valid, non-zero if iterator has reached end.
430  */
431 int gcov_iter_next(struct gcov_iterator *iter)
432 {
433         switch (iter->record) {
434         case RECORD_FILE_MAGIC:
435         case RECORD_GCOV_VERSION:
436         case RECORD_FUNCTION_TAG:
437         case RECORD_FUNCTON_TAG_LEN:
438         case RECORD_FUNCTION_IDENT:
439         case RECORD_COUNT_TAG:
440                 /* Advance to next record */
441                 iter->record++;
442                 break;
443         case RECORD_COUNT:
444                 /* Advance to next count */
445                 iter->count++;
446                 /* fall through */
447         case RECORD_COUNT_LEN:
448                 if (iter->count < get_func(iter)->n_ctrs[iter->type]) {
449                         iter->record = 9;
450                         break;
451                 }
452                 /* Advance to next counter type */
453                 get_type(iter)->offset += iter->count;
454                 iter->count = 0;
455                 iter->type++;
456                 /* fall through */
457         case RECORD_FUNCTION_CHECK:
458                 if (iter->type < iter->num_types) {
459                         iter->record = 7;
460                         break;
461                 }
462                 /* Advance to next function */
463                 iter->type = 0;
464                 iter->function++;
465                 /* fall through */
466         case RECORD_TIME_STAMP:
467                 if (iter->function < iter->info->n_functions)
468                         iter->record = 3;
469                 else
470                         iter->record = -1;
471                 break;
472         }
473         /* Check for EOF. */
474         if (iter->record == -1)
475                 return -EINVAL;
476         else
477                 return 0;
478 }
479
480 /**
481  * seq_write_gcov_u32 - write 32 bit number in gcov format to seq_file
482  * @seq: seq_file handle
483  * @v: value to be stored
484  *
485  * Number format defined by gcc: numbers are recorded in the 32 bit
486  * unsigned binary form of the endianness of the machine generating the
487  * file.
488  */
489 static int seq_write_gcov_u32(struct seq_file *seq, u32 v)
490 {
491         return seq_write(seq, &v, sizeof(v));
492 }
493
494 /**
495  * seq_write_gcov_u64 - write 64 bit number in gcov format to seq_file
496  * @seq: seq_file handle
497  * @v: value to be stored
498  *
499  * Number format defined by gcc: numbers are recorded in the 32 bit
500  * unsigned binary form of the endianness of the machine generating the
501  * file. 64 bit numbers are stored as two 32 bit numbers, the low part
502  * first.
503  */
504 static int seq_write_gcov_u64(struct seq_file *seq, u64 v)
505 {
506         u32 data[2];
507
508         data[0] = (v & 0xffffffffUL);
509         data[1] = (v >> 32);
510         return seq_write(seq, data, sizeof(data));
511 }
512
513 /**
514  * gcov_iter_write - write data for current pos to seq_file
515  * @iter: file iterator
516  * @seq: seq_file handle
517  *
518  * Return zero on success, non-zero otherwise.
519  */
520 int gcov_iter_write(struct gcov_iterator *iter, struct seq_file *seq)
521 {
522         int rc = -EINVAL;
523
524         switch (iter->record) {
525         case RECORD_FILE_MAGIC:
526                 rc = seq_write_gcov_u32(seq, GCOV_DATA_MAGIC);
527                 break;
528         case RECORD_GCOV_VERSION:
529                 rc = seq_write_gcov_u32(seq, iter->info->version);
530                 break;
531         case RECORD_TIME_STAMP:
532                 rc = seq_write_gcov_u32(seq, iter->info->stamp);
533                 break;
534         case RECORD_FUNCTION_TAG:
535                 rc = seq_write_gcov_u32(seq, GCOV_TAG_FUNCTION);
536                 break;
537         case RECORD_FUNCTON_TAG_LEN:
538                 rc = seq_write_gcov_u32(seq, 2);
539                 break;
540         case RECORD_FUNCTION_IDENT:
541                 rc = seq_write_gcov_u32(seq, get_func(iter)->ident);
542                 break;
543         case RECORD_FUNCTION_CHECK:
544                 rc = seq_write_gcov_u32(seq, get_func(iter)->checksum);
545                 break;
546         case RECORD_COUNT_TAG:
547                 rc = seq_write_gcov_u32(seq,
548                         GCOV_TAG_FOR_COUNTER(get_type(iter)->ctr_type));
549                 break;
550         case RECORD_COUNT_LEN:
551                 rc = seq_write_gcov_u32(seq,
552                                 get_func(iter)->n_ctrs[iter->type] * 2);
553                 break;
554         case RECORD_COUNT:
555                 rc = seq_write_gcov_u64(seq,
556                         iter->info->counts[iter->type].
557                                 values[iter->count + get_type(iter)->offset]);
558                 break;
559         }
560         return rc;
561 }