]>
git.proxmox.com Git - mirror_ubuntu-focal-kernel.git/blob - kernel/gcov/gcc_4_7.c
1 // SPDX-License-Identifier: GPL-2.0
3 * This code provides functions to handle gcc's profiling data format
4 * introduced with gcc 4.7.
6 * This file is based heavily on gcc_3_4.c file.
8 * For a better understanding, refer to gcc source:
12 * Uses gcc-internal data definitions.
15 #include <linux/errno.h>
16 #include <linux/slab.h>
17 #include <linux/string.h>
18 #include <linux/seq_file.h>
19 #include <linux/vmalloc.h>
23 #define GCOV_COUNTERS 8
25 #define GCOV_COUNTERS 9
26 #elif (__GNUC__ > 5) || (__GNUC__ == 5 && __GNUC_MINOR__ >= 1)
27 #define GCOV_COUNTERS 10
28 #elif __GNUC__ == 4 && __GNUC_MINOR__ >= 9
29 #define GCOV_COUNTERS 9
31 #define GCOV_COUNTERS 8
34 #define GCOV_TAG_FUNCTION_LENGTH 3
36 static struct gcov_info
*gcov_info_head
;
39 * struct gcov_ctr_info - information about counters for a single function
40 * @num: number of counter values for this type
41 * @values: array of counter values for this type
43 * This data is generated by gcc during compilation and doesn't change
44 * at run-time with the exception of the values array.
46 struct gcov_ctr_info
{
52 * struct gcov_fn_info - profiling meta data per function
54 * @ident: unique ident of function
55 * @lineno_checksum: function lineo_checksum
56 * @cfg_checksum: function cfg checksum
57 * @ctrs: instrumented counters
59 * This data is generated by gcc during compilation and doesn't change
62 * Information about a single function. This uses the trailing array
63 * idiom. The number of counters is determined from the merge pointer
64 * array in gcov_info. The key is used to detect which of a set of
65 * comdat functions was selected -- it points to the gcov_info object
66 * of the object file containing the selected comdat function.
69 const struct gcov_info
*key
;
71 unsigned int lineno_checksum
;
72 unsigned int cfg_checksum
;
73 struct gcov_ctr_info ctrs
[0];
77 * struct gcov_info - profiling data per object file
78 * @version: gcov version magic indicating the gcc version used for compilation
79 * @next: list head for a singly-linked list
80 * @stamp: uniquifying time stamp
81 * @filename: name of the associated gcov data file
82 * @merge: merge functions (null for unused counter type)
83 * @n_functions: number of instrumented functions
84 * @functions: pointer to pointers to function information
86 * This data is generated by gcc during compilation and doesn't change
87 * at run-time with the exception of the next pointer.
91 struct gcov_info
*next
;
94 void (*merge
[GCOV_COUNTERS
])(gcov_type
*, unsigned int);
95 unsigned int n_functions
;
96 struct gcov_fn_info
**functions
;
100 * gcov_info_filename - return info filename
101 * @info: profiling data set
103 const char *gcov_info_filename(struct gcov_info
*info
)
105 return info
->filename
;
109 * gcov_info_version - return info version
110 * @info: profiling data set
112 unsigned int gcov_info_version(struct gcov_info
*info
)
114 return info
->version
;
118 * gcov_info_next - return next profiling data set
119 * @info: profiling data set
121 * Returns next gcov_info following @info or first gcov_info in the chain if
124 struct gcov_info
*gcov_info_next(struct gcov_info
*info
)
127 return gcov_info_head
;
133 * gcov_info_link - link/add profiling data set to the list
134 * @info: profiling data set
136 void gcov_info_link(struct gcov_info
*info
)
138 info
->next
= gcov_info_head
;
139 gcov_info_head
= info
;
143 * gcov_info_unlink - unlink/remove profiling data set from the list
144 * @prev: previous profiling data set
145 * @info: profiling data set
147 void gcov_info_unlink(struct gcov_info
*prev
, struct gcov_info
*info
)
150 prev
->next
= info
->next
;
152 gcov_info_head
= info
->next
;
156 * gcov_info_within_module - check if a profiling data set belongs to a module
157 * @info: profiling data set
160 * Returns true if profiling data belongs module, false otherwise.
162 bool gcov_info_within_module(struct gcov_info
*info
, struct module
*mod
)
164 return within_module((unsigned long)info
, mod
);
167 /* Symbolic links to be created for each profiling data file. */
168 const struct gcov_link gcov_link
[] = {
169 { OBJ_TREE
, "gcno" }, /* Link to .gcno file in $(objtree). */
174 * Determine whether a counter is active. Doesn't change at run-time.
176 static int counter_active(struct gcov_info
*info
, unsigned int type
)
178 return info
->merge
[type
] ? 1 : 0;
181 /* Determine number of active counters. Based on gcc magic. */
182 static unsigned int num_counter_active(struct gcov_info
*info
)
185 unsigned int result
= 0;
187 for (i
= 0; i
< GCOV_COUNTERS
; i
++) {
188 if (counter_active(info
, i
))
195 * gcov_info_reset - reset profiling data to zero
196 * @info: profiling data set
198 void gcov_info_reset(struct gcov_info
*info
)
200 struct gcov_ctr_info
*ci_ptr
;
204 for (fi_idx
= 0; fi_idx
< info
->n_functions
; fi_idx
++) {
205 ci_ptr
= info
->functions
[fi_idx
]->ctrs
;
207 for (ct_idx
= 0; ct_idx
< GCOV_COUNTERS
; ct_idx
++) {
208 if (!counter_active(info
, ct_idx
))
211 memset(ci_ptr
->values
, 0,
212 sizeof(gcov_type
) * ci_ptr
->num
);
219 * gcov_info_is_compatible - check if profiling data can be added
220 * @info1: first profiling data set
221 * @info2: second profiling data set
223 * Returns non-zero if profiling data can be added, zero otherwise.
225 int gcov_info_is_compatible(struct gcov_info
*info1
, struct gcov_info
*info2
)
227 return (info1
->stamp
== info2
->stamp
);
231 * gcov_info_add - add up profiling data
232 * @dest: profiling data set to which data is added
233 * @source: profiling data set which is added
235 * Adds profiling counts of @source to @dest.
237 void gcov_info_add(struct gcov_info
*dst
, struct gcov_info
*src
)
239 struct gcov_ctr_info
*dci_ptr
;
240 struct gcov_ctr_info
*sci_ptr
;
243 unsigned int val_idx
;
245 for (fi_idx
= 0; fi_idx
< src
->n_functions
; fi_idx
++) {
246 dci_ptr
= dst
->functions
[fi_idx
]->ctrs
;
247 sci_ptr
= src
->functions
[fi_idx
]->ctrs
;
249 for (ct_idx
= 0; ct_idx
< GCOV_COUNTERS
; ct_idx
++) {
250 if (!counter_active(src
, ct_idx
))
253 for (val_idx
= 0; val_idx
< sci_ptr
->num
; val_idx
++)
254 dci_ptr
->values
[val_idx
] +=
255 sci_ptr
->values
[val_idx
];
264 * gcov_info_dup - duplicate profiling data set
265 * @info: profiling data set to duplicate
267 * Return newly allocated duplicate on success, %NULL on error.
269 struct gcov_info
*gcov_info_dup(struct gcov_info
*info
)
271 struct gcov_info
*dup
;
272 struct gcov_ctr_info
*dci_ptr
; /* dst counter info */
273 struct gcov_ctr_info
*sci_ptr
; /* src counter info */
275 unsigned int fi_idx
; /* function info idx */
276 unsigned int ct_idx
; /* counter type idx */
277 size_t fi_size
; /* function info size */
278 size_t cv_size
; /* counter values size */
280 dup
= kmemdup(info
, sizeof(*dup
), GFP_KERNEL
);
285 dup
->filename
= NULL
;
286 dup
->functions
= NULL
;
288 dup
->filename
= kstrdup(info
->filename
, GFP_KERNEL
);
292 dup
->functions
= kcalloc(info
->n_functions
,
293 sizeof(struct gcov_fn_info
*), GFP_KERNEL
);
297 active
= num_counter_active(info
);
298 fi_size
= sizeof(struct gcov_fn_info
);
299 fi_size
+= sizeof(struct gcov_ctr_info
) * active
;
301 for (fi_idx
= 0; fi_idx
< info
->n_functions
; fi_idx
++) {
302 dup
->functions
[fi_idx
] = kzalloc(fi_size
, GFP_KERNEL
);
303 if (!dup
->functions
[fi_idx
])
306 *(dup
->functions
[fi_idx
]) = *(info
->functions
[fi_idx
]);
308 sci_ptr
= info
->functions
[fi_idx
]->ctrs
;
309 dci_ptr
= dup
->functions
[fi_idx
]->ctrs
;
311 for (ct_idx
= 0; ct_idx
< active
; ct_idx
++) {
313 cv_size
= sizeof(gcov_type
) * sci_ptr
->num
;
315 dci_ptr
->values
= vmalloc(cv_size
);
317 if (!dci_ptr
->values
)
320 dci_ptr
->num
= sci_ptr
->num
;
321 memcpy(dci_ptr
->values
, sci_ptr
->values
, cv_size
);
335 * gcov_info_free - release memory for profiling data set duplicate
336 * @info: profiling data set duplicate to free
338 void gcov_info_free(struct gcov_info
*info
)
343 struct gcov_ctr_info
*ci_ptr
;
345 if (!info
->functions
)
348 active
= num_counter_active(info
);
350 for (fi_idx
= 0; fi_idx
< info
->n_functions
; fi_idx
++) {
351 if (!info
->functions
[fi_idx
])
354 ci_ptr
= info
->functions
[fi_idx
]->ctrs
;
356 for (ct_idx
= 0; ct_idx
< active
; ct_idx
++, ci_ptr
++)
357 vfree(ci_ptr
->values
);
359 kfree(info
->functions
[fi_idx
]);
363 kfree(info
->functions
);
364 kfree(info
->filename
);
368 #define ITER_STRIDE PAGE_SIZE
371 * struct gcov_iterator - specifies current file position in logical records
372 * @info: associated profiling data
373 * @buffer: buffer containing file data
374 * @size: size of buffer
375 * @pos: current position in file
377 struct gcov_iterator
{
378 struct gcov_info
*info
;
385 * store_gcov_u32 - store 32 bit number in gcov format to buffer
386 * @buffer: target buffer or NULL
387 * @off: offset into the buffer
388 * @v: value to be stored
390 * Number format defined by gcc: numbers are recorded in the 32 bit
391 * unsigned binary form of the endianness of the machine generating the
392 * file. Returns the number of bytes stored. If @buffer is %NULL, doesn't
395 static size_t store_gcov_u32(void *buffer
, size_t off
, u32 v
)
404 return sizeof(*data
);
408 * store_gcov_u64 - store 64 bit number in gcov format to buffer
409 * @buffer: target buffer or NULL
410 * @off: offset into the buffer
411 * @v: value to be stored
413 * Number format defined by gcc: numbers are recorded in the 32 bit
414 * unsigned binary form of the endianness of the machine generating the
415 * file. 64 bit numbers are stored as two 32 bit numbers, the low part
416 * first. Returns the number of bytes stored. If @buffer is %NULL, doesn't store
419 static size_t store_gcov_u64(void *buffer
, size_t off
, u64 v
)
426 data
[0] = (v
& 0xffffffffUL
);
430 return sizeof(*data
) * 2;
434 * convert_to_gcda - convert profiling data set to gcda file format
435 * @buffer: the buffer to store file data or %NULL if no data should be stored
436 * @info: profiling data set to be converted
438 * Returns the number of bytes that were/would have been stored into the buffer.
440 static size_t convert_to_gcda(char *buffer
, struct gcov_info
*info
)
442 struct gcov_fn_info
*fi_ptr
;
443 struct gcov_ctr_info
*ci_ptr
;
450 pos
+= store_gcov_u32(buffer
, pos
, GCOV_DATA_MAGIC
);
451 pos
+= store_gcov_u32(buffer
, pos
, info
->version
);
452 pos
+= store_gcov_u32(buffer
, pos
, info
->stamp
);
454 for (fi_idx
= 0; fi_idx
< info
->n_functions
; fi_idx
++) {
455 fi_ptr
= info
->functions
[fi_idx
];
457 /* Function record. */
458 pos
+= store_gcov_u32(buffer
, pos
, GCOV_TAG_FUNCTION
);
459 pos
+= store_gcov_u32(buffer
, pos
, GCOV_TAG_FUNCTION_LENGTH
);
460 pos
+= store_gcov_u32(buffer
, pos
, fi_ptr
->ident
);
461 pos
+= store_gcov_u32(buffer
, pos
, fi_ptr
->lineno_checksum
);
462 pos
+= store_gcov_u32(buffer
, pos
, fi_ptr
->cfg_checksum
);
464 ci_ptr
= fi_ptr
->ctrs
;
466 for (ct_idx
= 0; ct_idx
< GCOV_COUNTERS
; ct_idx
++) {
467 if (!counter_active(info
, ct_idx
))
470 /* Counter record. */
471 pos
+= store_gcov_u32(buffer
, pos
,
472 GCOV_TAG_FOR_COUNTER(ct_idx
));
473 pos
+= store_gcov_u32(buffer
, pos
, ci_ptr
->num
* 2);
475 for (cv_idx
= 0; cv_idx
< ci_ptr
->num
; cv_idx
++) {
476 pos
+= store_gcov_u64(buffer
, pos
,
477 ci_ptr
->values
[cv_idx
]);
488 * gcov_iter_new - allocate and initialize profiling data iterator
489 * @info: profiling data set to be iterated
491 * Return file iterator on success, %NULL otherwise.
493 struct gcov_iterator
*gcov_iter_new(struct gcov_info
*info
)
495 struct gcov_iterator
*iter
;
497 iter
= kzalloc(sizeof(struct gcov_iterator
), GFP_KERNEL
);
502 /* Dry-run to get the actual buffer size. */
503 iter
->size
= convert_to_gcda(NULL
, info
);
504 iter
->buffer
= vmalloc(iter
->size
);
508 convert_to_gcda(iter
->buffer
, info
);
519 * gcov_iter_get_info - return profiling data set for given file iterator
520 * @iter: file iterator
522 void gcov_iter_free(struct gcov_iterator
*iter
)
529 * gcov_iter_get_info - return profiling data set for given file iterator
530 * @iter: file iterator
532 struct gcov_info
*gcov_iter_get_info(struct gcov_iterator
*iter
)
538 * gcov_iter_start - reset file iterator to starting position
539 * @iter: file iterator
541 void gcov_iter_start(struct gcov_iterator
*iter
)
547 * gcov_iter_next - advance file iterator to next logical record
548 * @iter: file iterator
550 * Return zero if new position is valid, non-zero if iterator has reached end.
552 int gcov_iter_next(struct gcov_iterator
*iter
)
554 if (iter
->pos
< iter
->size
)
555 iter
->pos
+= ITER_STRIDE
;
557 if (iter
->pos
>= iter
->size
)
564 * gcov_iter_write - write data for current pos to seq_file
565 * @iter: file iterator
566 * @seq: seq_file handle
568 * Return zero on success, non-zero otherwise.
570 int gcov_iter_write(struct gcov_iterator
*iter
, struct seq_file
*seq
)
574 if (iter
->pos
>= iter
->size
)
578 if (iter
->pos
+ len
> iter
->size
)
579 len
= iter
->size
- iter
->pos
;
581 seq_write(seq
, iter
->buffer
+ iter
->pos
, len
);