1 // SPDX-License-Identifier: GPL-2.0
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.
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.
12 * Copyright IBM Corp. 2009
13 * Author(s): Peter Oberparleiter <oberpar@linux.vnet.ibm.com>
15 * Uses gcc-internal data definitions.
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>
25 #define GCOV_COUNTERS 5
27 static struct gcov_info *gcov_info_head;
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
35 * This data is generated by gcc during compilation and doesn't change
40 unsigned int checksum;
41 unsigned int n_ctrs[0];
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)
50 * This data is generated by gcc during compilation and doesn't change
51 * at run-time with the exception of the values array.
53 struct gcov_ctr_info {
56 void (*merge)(gcov_type *, unsigned int);
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
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
70 * This data is generated by gcc during compilation and doesn't change
71 * at run-time with the exception of the next pointer.
75 struct gcov_info *next;
78 unsigned int n_functions;
79 const struct gcov_fn_info *functions;
80 unsigned int ctr_mask;
81 struct gcov_ctr_info counts[0];
85 * gcov_info_filename - return info filename
86 * @info: profiling data set
88 const char *gcov_info_filename(struct gcov_info *info)
90 return info->filename;
94 * gcov_info_version - return info version
95 * @info: profiling data set
97 unsigned int gcov_info_version(struct gcov_info *info)
103 * gcov_info_next - return next profiling data set
104 * @info: profiling data set
106 * Returns next gcov_info following @info or first gcov_info in the chain if
109 struct gcov_info *gcov_info_next(struct gcov_info *info)
112 return gcov_info_head;
118 * gcov_info_link - link/add profiling data set to the list
119 * @info: profiling data set
121 void gcov_info_link(struct gcov_info *info)
123 info->next = gcov_info_head;
124 gcov_info_head = info;
128 * gcov_info_unlink - unlink/remove profiling data set from the list
129 * @prev: previous profiling data set
130 * @info: profiling data set
132 void gcov_info_unlink(struct gcov_info *prev, struct gcov_info *info)
135 prev->next = info->next;
137 gcov_info_head = info->next;
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). */
147 * Determine whether a counter is active. Based on gcc magic. Doesn't change
150 static int counter_active(struct gcov_info *info, unsigned int type)
152 return (1 << type) & info->ctr_mask;
155 /* Determine number of active counters. Based on gcc magic. */
156 static unsigned int num_counter_active(struct gcov_info *info)
159 unsigned int result = 0;
161 for (i = 0; i < GCOV_COUNTERS; i++) {
162 if (counter_active(info, i))
169 * gcov_info_reset - reset profiling data to zero
170 * @info: profiling data set
172 void gcov_info_reset(struct gcov_info *info)
174 unsigned int active = num_counter_active(info);
177 for (i = 0; i < active; i++) {
178 memset(info->counts[i].values, 0,
179 info->counts[i].num * sizeof(gcov_type));
184 * gcov_info_is_compatible - check if profiling data can be added
185 * @info1: first profiling data set
186 * @info2: second profiling data set
188 * Returns non-zero if profiling data can be added, zero otherwise.
190 int gcov_info_is_compatible(struct gcov_info *info1, struct gcov_info *info2)
192 return (info1->stamp == info2->stamp);
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
200 * Adds profiling counts of @source to @dest.
202 void gcov_info_add(struct gcov_info *dest, struct gcov_info *source)
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];
215 /* Get size of function info entry. Based on gcc magic. */
216 static size_t get_fn_size(struct gcov_info *info)
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));
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)
230 return (struct gcov_fn_info *)
231 ((char *) info->functions + fn * get_fn_size(info));
235 * gcov_info_dup - duplicate profiling data set
236 * @info: profiling data set to duplicate
238 * Return newly allocated duplicate on success, %NULL on error.
240 struct gcov_info *gcov_info_dup(struct gcov_info *info)
242 struct gcov_info *dup;
246 /* Duplicate gcov_info. */
247 active = num_counter_active(info);
248 dup = kzalloc(struct_size(dup, counts, active), GFP_KERNEL);
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);
259 /* Duplicate table of functions. */
260 dup->functions = kmemdup(info->functions, info->n_functions *
261 get_fn_size(info), GFP_KERNEL);
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);
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)
274 memcpy(dup->counts[i].values, ctr->values, size);
284 * gcov_info_free - release memory for profiling data set duplicate
285 * @info: profiling data set duplicate to free
287 void gcov_info_free(struct gcov_info *info)
289 unsigned int active = num_counter_active(info);
292 for (i = 0; i < active ; i++)
293 vfree(info->counts[i].values);
294 kfree(info->functions);
295 kfree(info->filename);
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
304 * This array is needed to convert the in-memory data format into the in-file
308 * for each counter type
314 * for each counter type
317 * See gcc source gcc/gcov-io.h for more information on data organization.
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
334 struct gcov_iterator {
335 struct gcov_info *info;
338 unsigned int function;
343 struct type_info type_info[0];
346 static struct gcov_fn_info *get_func(struct gcov_iterator *iter)
348 return get_fn_info(iter->info, iter->function);
351 static struct type_info *get_type(struct gcov_iterator *iter)
353 return &iter->type_info[iter->type];
357 * gcov_iter_new - allocate and initialize profiling data iterator
358 * @info: profiling data set to be iterated
360 * Return file iterator on success, %NULL otherwise.
362 struct gcov_iterator *gcov_iter_new(struct gcov_info *info)
364 struct gcov_iterator *iter;
366 iter = kzalloc(struct_size(iter, type_info, num_counter_active(info)),
375 * gcov_iter_free - release memory for iterator
376 * @iter: file iterator to free
378 void gcov_iter_free(struct gcov_iterator *iter)
384 * gcov_iter_get_info - return profiling data set for given file iterator
385 * @iter: file iterator
387 struct gcov_info *gcov_iter_get_info(struct gcov_iterator *iter)
393 * gcov_iter_start - reset file iterator to starting position
394 * @iter: file iterator
396 void gcov_iter_start(struct gcov_iterator *iter)
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;
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
426 * gcov_iter_next - advance file iterator to next logical record
427 * @iter: file iterator
429 * Return zero if new position is valid, non-zero if iterator has reached end.
431 int gcov_iter_next(struct gcov_iterator *iter)
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 */
444 /* Advance to next count */
447 case RECORD_COUNT_LEN:
448 if (iter->count < get_func(iter)->n_ctrs[iter->type]) {
452 /* Advance to next counter type */
453 get_type(iter)->offset += iter->count;
457 case RECORD_FUNCTION_CHECK:
458 if (iter->type < iter->num_types) {
462 /* Advance to next function */
466 case RECORD_TIME_STAMP:
467 if (iter->function < iter->info->n_functions)
474 if (iter->record == -1)
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
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
489 static int seq_write_gcov_u32(struct seq_file *seq, u32 v)
491 return seq_write(seq, &v, sizeof(v));
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
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
504 static int seq_write_gcov_u64(struct seq_file *seq, u64 v)
508 data[0] = (v & 0xffffffffUL);
510 return seq_write(seq, data, sizeof(data));
514 * gcov_iter_write - write data for current pos to seq_file
515 * @iter: file iterator
516 * @seq: seq_file handle
518 * Return zero on success, non-zero otherwise.
520 int gcov_iter_write(struct gcov_iterator *iter, struct seq_file *seq)
524 switch (iter->record) {
525 case RECORD_FILE_MAGIC:
526 rc = seq_write_gcov_u32(seq, GCOV_DATA_MAGIC);
528 case RECORD_GCOV_VERSION:
529 rc = seq_write_gcov_u32(seq, iter->info->version);
531 case RECORD_TIME_STAMP:
532 rc = seq_write_gcov_u32(seq, iter->info->stamp);
534 case RECORD_FUNCTION_TAG:
535 rc = seq_write_gcov_u32(seq, GCOV_TAG_FUNCTION);
537 case RECORD_FUNCTON_TAG_LEN:
538 rc = seq_write_gcov_u32(seq, 2);
540 case RECORD_FUNCTION_IDENT:
541 rc = seq_write_gcov_u32(seq, get_func(iter)->ident);
543 case RECORD_FUNCTION_CHECK:
544 rc = seq_write_gcov_u32(seq, get_func(iter)->checksum);
546 case RECORD_COUNT_TAG:
547 rc = seq_write_gcov_u32(seq,
548 GCOV_TAG_FOR_COUNTER(get_type(iter)->ctr_type));
550 case RECORD_COUNT_LEN:
551 rc = seq_write_gcov_u32(seq,
552 get_func(iter)->n_ctrs[iter->type] * 2);
555 rc = seq_write_gcov_u64(seq,
556 iter->info->counts[iter->type].
557 values[iter->count + get_type(iter)->offset]);