[linux.git] / kernel / gcov / gcc_3_4.c

/*
 *  This code provides functions to handle gcc's profiling data format
 *  introduced with gcc 3.4. Future versions of gcc may change the gcov
 *  format (as happened before), so all format-specific information needs
 *  to be kept modular and easily exchangeable.
 *
 *  This file is based on gcc-internal definitions. Functions and data
 *  structures are defined to be compatible with gcc counterparts.
 *  For a better understanding, refer to gcc source: gcc/gcov-io.h.
 *
 *    Copyright IBM Corp. 2009
 *    Author(s): Peter Oberparleiter <[email protected]>
 *
 *    Uses gcc-internal data definitions.
 */

#include <linux/errno.h>
#include <linux/slab.h>
#include <linux/string.h>
#include <linux/seq_file.h>
#include <linux/vmalloc.h>
#include "gcov.h"

/* Symbolic links to be created for each profiling data file. */
const struct gcov_link gcov_link[] = {
	{ OBJ_TREE, "gcno" },	/* Link to .gcno file in $(objtree). */
	{ 0, NULL},
};

/*
 * Determine whether a counter is active. Based on gcc magic. Doesn't change
 * at run-time.
 */
static int counter_active(struct gcov_info *info, unsigned int type)
{
	return (1 << type) & info->ctr_mask;
}

/* Determine number of active counters. Based on gcc magic. */
static unsigned int num_counter_active(struct gcov_info *info)
{
	unsigned int i;
	unsigned int result = 0;

	for (i = 0; i < GCOV_COUNTERS; i++) {
		if (counter_active(info, i))
			result++;
	}
	return result;
}

/**
 * gcov_info_reset - reset profiling data to zero
 * @info: profiling data set
 */
void gcov_info_reset(struct gcov_info *info)
{
	unsigned int active = num_counter_active(info);
	unsigned int i;

	for (i = 0; i < active; i++) {
		memset(info->counts[i].values, 0,
		       info->counts[i].num * sizeof(gcov_type));
	}
}

/**
 * gcov_info_is_compatible - check if profiling data can be added
 * @info1: first profiling data set
 * @info2: second profiling data set
 *
 * Returns non-zero if profiling data can be added, zero otherwise.
 */
int gcov_info_is_compatible(struct gcov_info *info1, struct gcov_info *info2)
{
	return (info1->stamp == info2->stamp);
}

/**
 * gcov_info_add - add up profiling data
 * @dest: profiling data set to which data is added
 * @source: profiling data set which is added
 *
 * Adds profiling counts of @source to @dest.
 */
void gcov_info_add(struct gcov_info *dest, struct gcov_info *source)
{
	unsigned int i;
	unsigned int j;

	for (i = 0; i < num_counter_active(dest); i++) {
		for (j = 0; j < dest->counts[i].num; j++) {
			dest->counts[i].values[j] +=
				source->counts[i].values[j];
		}
	}
}

/* Get size of function info entry. Based on gcc magic. */
static size_t get_fn_size(struct gcov_info *info)
{
	size_t size;

	size = sizeof(struct gcov_fn_info) + num_counter_active(info) *
	       sizeof(unsigned int);
	if (__alignof__(struct gcov_fn_info) > sizeof(unsigned int))
		size = ALIGN(size, __alignof__(struct gcov_fn_info));
	return size;
}

/* Get address of function info entry. Based on gcc magic. */
static struct gcov_fn_info *get_fn_info(struct gcov_info *info, unsigned int fn)
{
	return (struct gcov_fn_info *)
		((char *) info->functions + fn * get_fn_size(info));
}

/**
 * gcov_info_dup - duplicate profiling data set
 * @info: profiling data set to duplicate
 *
 * Return newly allocated duplicate on success, %NULL on error.
 */
struct gcov_info *gcov_info_dup(struct gcov_info *info)
{
	struct gcov_info *dup;
	unsigned int i;
	unsigned int active;

	/* Duplicate gcov_info. */
	active = num_counter_active(info);
	dup = kzalloc(sizeof(struct gcov_info) +
		      sizeof(struct gcov_ctr_info) * active, GFP_KERNEL);
	if (!dup)
		return NULL;
	dup->version		= info->version;
	dup->stamp		= info->stamp;
	dup->n_functions	= info->n_functions;
	dup->ctr_mask		= info->ctr_mask;
	/* Duplicate filename. */
	dup->filename		= kstrdup(info->filename, GFP_KERNEL);
	if (!dup->filename)
		goto err_free;
	/* Duplicate table of functions. */
	dup->functions = kmemdup(info->functions, info->n_functions *
				 get_fn_size(info), GFP_KERNEL);
	if (!dup->functions)
		goto err_free;
	/* Duplicate counter arrays. */
	for (i = 0; i < active ; i++) {
		struct gcov_ctr_info *ctr = &info->counts[i];
		size_t size = ctr->num * sizeof(gcov_type);

		dup->counts[i].num = ctr->num;
		dup->counts[i].merge = ctr->merge;
		dup->counts[i].values = vmalloc(size);
		if (!dup->counts[i].values)
			goto err_free;
		memcpy(dup->counts[i].values, ctr->values, size);
	}
	return dup;

err_free:
	gcov_info_free(dup);
	return NULL;
}

/**
 * gcov_info_free - release memory for profiling data set duplicate
 * @info: profiling data set duplicate to free
 */
void gcov_info_free(struct gcov_info *info)
{
	unsigned int active = num_counter_active(info);
	unsigned int i;

	for (i = 0; i < active ; i++)
		vfree(info->counts[i].values);
	kfree(info->functions);
	kfree(info->filename);
	kfree(info);
}

/**
 * struct type_info - iterator helper array
 * @ctr_type: counter type
 * @offset: index of the first value of the current function for this type
 *
 * This array is needed to convert the in-memory data format into the in-file
 * data format:
 *
 * In-memory:
 *   for each counter type
 *     for each function
 *       values
 *
 * In-file:
 *   for each function
 *     for each counter type
 *       values
 *
 * See gcc source gcc/gcov-io.h for more information on data organization.
 */
struct type_info {
	int ctr_type;
	unsigned int offset;
};

/**
 * struct gcov_iterator - specifies current file position in logical records
 * @info: associated profiling data
 * @record: record type
 * @function: function number
 * @type: counter type
 * @count: index into values array
 * @num_types: number of counter types
 * @type_info: helper array to get values-array offset for current function
 */
struct gcov_iterator {
	struct gcov_info *info;

	int record;
	unsigned int function;
	unsigned int type;
	unsigned int count;

	int num_types;
	struct type_info type_info[0];
};

static struct gcov_fn_info *get_func(struct gcov_iterator *iter)
{
	return get_fn_info(iter->info, iter->function);
}

static struct type_info *get_type(struct gcov_iterator *iter)
{
	return &iter->type_info[iter->type];
}

/**
 * gcov_iter_new - allocate and initialize profiling data iterator
 * @info: profiling data set to be iterated
 *
 * Return file iterator on success, %NULL otherwise.
 */
struct gcov_iterator *gcov_iter_new(struct gcov_info *info)
{
	struct gcov_iterator *iter;

	iter = kzalloc(sizeof(struct gcov_iterator) +
		       num_counter_active(info) * sizeof(struct type_info),
		       GFP_KERNEL);
	if (iter)
		iter->info = info;

	return iter;
}

/**
 * gcov_iter_free - release memory for iterator
 * @iter: file iterator to free
 */
void gcov_iter_free(struct gcov_iterator *iter)
{
	kfree(iter);
}

/**
 * gcov_iter_get_info - return profiling data set for given file iterator
 * @iter: file iterator
 */
struct gcov_info *gcov_iter_get_info(struct gcov_iterator *iter)
{
	return iter->info;
}

/**
 * gcov_iter_start - reset file iterator to starting position
 * @iter: file iterator
 */
void gcov_iter_start(struct gcov_iterator *iter)
{
	int i;

	iter->record = 0;
	iter->function = 0;
	iter->type = 0;
	iter->count = 0;
	iter->num_types = 0;
	for (i = 0; i < GCOV_COUNTERS; i++) {
		if (counter_active(iter->info, i)) {
			iter->type_info[iter->num_types].ctr_type = i;
			iter->type_info[iter->num_types++].offset = 0;
		}
	}
}

/* Mapping of logical record number to actual file content. */
#define RECORD_FILE_MAGIC	0
#define RECORD_GCOV_VERSION	1
#define RECORD_TIME_STAMP	2
#define RECORD_FUNCTION_TAG	3
#define RECORD_FUNCTON_TAG_LEN	4
#define RECORD_FUNCTION_IDENT	5
#define RECORD_FUNCTION_CHECK	6
#define RECORD_COUNT_TAG	7
#define RECORD_COUNT_LEN	8
#define RECORD_COUNT		9

/**
 * gcov_iter_next - advance file iterator to next logical record
 * @iter: file iterator
 *
 * Return zero if new position is valid, non-zero if iterator has reached end.
 */
int gcov_iter_next(struct gcov_iterator *iter)
{
	switch (iter->record) {
	case RECORD_FILE_MAGIC:
	case RECORD_GCOV_VERSION:
	case RECORD_FUNCTION_TAG:
	case RECORD_FUNCTON_TAG_LEN:
	case RECORD_FUNCTION_IDENT:
	case RECORD_COUNT_TAG:
		/* Advance to next record */
		iter->record++;
		break;
	case RECORD_COUNT:
		/* Advance to next count */
		iter->count++;
		/* fall through */
	case RECORD_COUNT_LEN:
		if (iter->count < get_func(iter)->n_ctrs[iter->type]) {
			iter->record = 9;
			break;
		}
		/* Advance to next counter type */
		get_type(iter)->offset += iter->count;
		iter->count = 0;
		iter->type++;
		/* fall through */
	case RECORD_FUNCTION_CHECK:
		if (iter->type < iter->num_types) {
			iter->record = 7;
			break;
		}
		/* Advance to next function */
		iter->type = 0;
		iter->function++;
		/* fall through */
	case RECORD_TIME_STAMP:
		if (iter->function < iter->info->n_functions)
			iter->record = 3;
		else
			iter->record = -1;
		break;
	}
	/* Check for EOF. */
	if (iter->record == -1)
		return -EINVAL;
	else
		return 0;
}

/**
 * seq_write_gcov_u32 - write 32 bit number in gcov format to seq_file
 * @seq: seq_file handle
 * @v: value to be stored
 *
 * Number format defined by gcc: numbers are recorded in the 32 bit
 * unsigned binary form of the endianness of the machine generating the
 * file.
 */
static int seq_write_gcov_u32(struct seq_file *seq, u32 v)
{
	return seq_write(seq, &v, sizeof(v));
}

/**
 * seq_write_gcov_u64 - write 64 bit number in gcov format to seq_file
 * @seq: seq_file handle
 * @v: value to be stored
 *
 * Number format defined by gcc: numbers are recorded in the 32 bit
 * unsigned binary form of the endianness of the machine generating the
 * file. 64 bit numbers are stored as two 32 bit numbers, the low part
 * first.
 */
static int seq_write_gcov_u64(struct seq_file *seq, u64 v)
{
	u32 data[2];

	data[0] = (v & 0xffffffffUL);
	data[1] = (v >> 32);
	return seq_write(seq, data, sizeof(data));
}

/**
 * gcov_iter_write - write data for current pos to seq_file
 * @iter: file iterator
 * @seq: seq_file handle
 *
 * Return zero on success, non-zero otherwise.
 */
int gcov_iter_write(struct gcov_iterator *iter, struct seq_file *seq)
{
	int rc = -EINVAL;

	switch (iter->record) {
	case RECORD_FILE_MAGIC:
		rc = seq_write_gcov_u32(seq, GCOV_DATA_MAGIC);
		break;
	case RECORD_GCOV_VERSION:
		rc = seq_write_gcov_u32(seq, iter->info->version);
		break;
	case RECORD_TIME_STAMP:
		rc = seq_write_gcov_u32(seq, iter->info->stamp);
		break;
	case RECORD_FUNCTION_TAG:
		rc = seq_write_gcov_u32(seq, GCOV_TAG_FUNCTION);
		break;
	case RECORD_FUNCTON_TAG_LEN:
		rc = seq_write_gcov_u32(seq, 2);
		break;
	case RECORD_FUNCTION_IDENT:
		rc = seq_write_gcov_u32(seq, get_func(iter)->ident);
		break;
	case RECORD_FUNCTION_CHECK:
		rc = seq_write_gcov_u32(seq, get_func(iter)->checksum);
		break;
	case RECORD_COUNT_TAG:
		rc = seq_write_gcov_u32(seq,
			GCOV_TAG_FOR_COUNTER(get_type(iter)->ctr_type));
		break;
	case RECORD_COUNT_LEN:
		rc = seq_write_gcov_u32(seq,
				get_func(iter)->n_ctrs[iter->type] * 2);
		break;
	case RECORD_COUNT:
		rc = seq_write_gcov_u64(seq,
			iter->info->counts[iter->type].
				values[iter->count + get_type(iter)->offset]);
		break;
	}
	return rc;
}
Commit	Line	Data
2521f2c2 PO	1	/*
	2	* This code provides functions to handle gcc's profiling data format
	3	* introduced with gcc 3.4. Future versions of gcc may change the gcov
	4	* format (as happened before), so all format-specific information needs
	5	* to be kept modular and easily exchangeable.
	6	*
	7	* This file is based on gcc-internal definitions. Functions and data
	8	* structures are defined to be compatible with gcc counterparts.
	9	* For a better understanding, refer to gcc source: gcc/gcov-io.h.
	10	*
	11	* Copyright IBM Corp. 2009
	12	* Author(s): Peter Oberparleiter <[email protected]>
	13	*
	14	* Uses gcc-internal data definitions.
	15	*/
	16
	17	#include <linux/errno.h>
	18	#include <linux/slab.h>
	19	#include <linux/string.h>
	20	#include <linux/seq_file.h>
	21	#include <linux/vmalloc.h>
	22	#include "gcov.h"
	23
	24	/* Symbolic links to be created for each profiling data file. */
	25	const struct gcov_link gcov_link[] = {
	26	{ OBJ_TREE, "gcno" }, /* Link to .gcno file in $(objtree). */
	27	{ 0, NULL},
	28	};
	29
	30	/*
	31	* Determine whether a counter is active. Based on gcc magic. Doesn't change
	32	* at run-time.
	33	*/
	34	static int counter_active(struct gcov_info *info, unsigned int type)
	35	{
	36	return (1 << type) & info->ctr_mask;
	37	}
	38
	39	/* Determine number of active counters. Based on gcc magic. */
	40	static unsigned int num_counter_active(struct gcov_info *info)
	41	{
	42	unsigned int i;
	43	unsigned int result = 0;
	44
	45	for (i = 0; i < GCOV_COUNTERS; i++) {
	46	if (counter_active(info, i))
	47	result++;
	48	}
	49	return result;
	50	}
	51
	52	/**
	53	* gcov_info_reset - reset profiling data to zero
	54	* @info: profiling data set
	55	*/
	56	void gcov_info_reset(struct gcov_info *info)
	57	{
	58	unsigned int active = num_counter_active(info);
	59	unsigned int i;
	60
	61	for (i = 0; i < active; i++) {
	62	memset(info->counts[i].values, 0,
	63	info->counts[i].num * sizeof(gcov_type));
	64	}
65	}
66
67	/**
68	* gcov_info_is_compatible - check if profiling data can be added
69	* @info1: first profiling data set
70	* @info2: second profiling data set
71	*
72	* Returns non-zero if profiling data can be added, zero otherwise.
73	*/
74	int gcov_info_is_compatible(struct gcov_info info1, struct gcov_info info2)
75	{
76	return (info1->stamp == info2->stamp);
77	}
78
79	/**
80	* gcov_info_add - add up profiling data
81	* @dest: profiling data set to which data is added
82	* @source: profiling data set which is added
83	*
84	* Adds profiling counts of @source to @dest.
85	*/
86	void gcov_info_add(struct gcov_info dest, struct gcov_info source)
87	{
88	unsigned int i;
89	unsigned int j;
90
91	for (i = 0; i < num_counter_active(dest); i++) {
92	for (j = 0; j < dest->counts[i].num; j++) {
93	dest->counts[i].values[j] +=
94	source->counts[i].values[j];
95	}
96	}
97	}
98
99	/* Get size of function info entry. Based on gcc magic. */
100	static size_t get_fn_size(struct gcov_info *info)
101	{
102	size_t size;
103
104	size = sizeof(struct gcov_fn_info) + num_counter_active(info) *
105	sizeof(unsigned int);
106	if (__alignof__(struct gcov_fn_info) > sizeof(unsigned int))
107	size = ALIGN(size, __alignof__(struct gcov_fn_info));
108	return size;
109	}
110
111	/* Get address of function info entry. Based on gcc magic. */
112	static struct gcov_fn_info get_fn_info(struct gcov_info info, unsigned int fn)
113	{
114	return (struct gcov_fn_info *)
115	((char ) info->functions + fn get_fn_size(info));
116	}
117
118	/**
119	* gcov_info_dup - duplicate profiling data set
120	* @info: profiling data set to duplicate
121	*
122	* Return newly allocated duplicate on success, %NULL on error.
123	*/
124	struct gcov_info gcov_info_dup(struct gcov_info info)
125	{
126	struct gcov_info *dup;
127	unsigned int i;
128	unsigned int active;
129
130	/* Duplicate gcov_info. */
131	active = num_counter_active(info);
132	dup = kzalloc(sizeof(struct gcov_info) +
133	sizeof(struct gcov_ctr_info) * active, GFP_KERNEL);
134	if (!dup)
135	return NULL;
136	dup->version = info->version;
137	dup->stamp = info->stamp;
138	dup->n_functions = info->n_functions;
139	dup->ctr_mask = info->ctr_mask;
140	/* Duplicate filename. */
141	dup->filename = kstrdup(info->filename, GFP_KERNEL);
142	if (!dup->filename)
143	goto err_free;
144	/* Duplicate table of functions. */
145	dup->functions = kmemdup(info->functions, info->n_functions *
146	get_fn_size(info), GFP_KERNEL);
147	if (!dup->functions)
148	goto err_free;
149	/* Duplicate counter arrays. */
150	for (i = 0; i < active ; i++) {
151	struct gcov_ctr_info *ctr = &info->counts[i];
152	size_t size = ctr->num * sizeof(gcov_type);
153
154	dup->counts[i].num = ctr->num;
155	dup->counts[i].merge = ctr->merge;
156	dup->counts[i].values = vmalloc(size);
157	if (!dup->counts[i].values)
158	goto err_free;
159	memcpy(dup->counts[i].values, ctr->values, size);
160	}
161	return dup;
162
163	err_free:
164	gcov_info_free(dup);
165	return NULL;
166	}
167
168	/**
169	* gcov_info_free - release memory for profiling data set duplicate
170	* @info: profiling data set duplicate to free
171	*/
172	void gcov_info_free(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	vfree(info->counts[i].values);
179	kfree(info->functions);
180	kfree(info->filename);
181	kfree(info);
182	}
183
184	/**
185	* struct type_info - iterator helper array
186	* @ctr_type: counter type
187	* @offset: index of the first value of the current function for this type
188	*
189	* This array is needed to convert the in-memory data format into the in-file
190	* data format:
191	*
192	* In-memory:
193	* for each counter type
194	* for each function
195	* values
196	*
197	* In-file:
198	* for each function
199	* for each counter type
200	* values
201	*
202	* See gcc source gcc/gcov-io.h for more information on data organization.
203	*/
204	struct type_info {
205	int ctr_type;
206	unsigned int offset;
207	};
208
209	/**
210	* struct gcov_iterator - specifies current file position in logical records
211	* @info: associated profiling data
212	* @record: record type
213	* @function: function number
214	* @type: counter type
215	* @count: index into values array
216	* @num_types: number of counter types
217	* @type_info: helper array to get values-array offset for current function
218	*/
219	struct gcov_iterator {
220	struct gcov_info *info;
221
222	int record;
223	unsigned int function;
224	unsigned int type;
225	unsigned int count;
226
227	int num_types;
228	struct type_info type_info[0];
229	};
230
231	static struct gcov_fn_info get_func(struct gcov_iterator iter)
232	{
233	return get_fn_info(iter->info, iter->function);
234	}
235
236	static struct type_info get_type(struct gcov_iterator iter)
237	{
238	return &iter->type_info[iter->type];
239	}
240
241	/**
242	* gcov_iter_new - allocate and initialize profiling data iterator
243	* @info: profiling data set to be iterated
244	*
245	* Return file iterator on success, %NULL otherwise.
246	*/
247	struct gcov_iterator gcov_iter_new(struct gcov_info info)
248	{
249	struct gcov_iterator *iter;
250
251	iter = kzalloc(sizeof(struct gcov_iterator) +
252	num_counter_active(info) * sizeof(struct type_info),
253	GFP_KERNEL);
254	if (iter)
255	iter->info = info;
256
257	return iter;
258	}
259
260	/**
261	* gcov_iter_free - release memory for iterator
262	* @iter: file iterator to free
263	*/
264	void gcov_iter_free(struct gcov_iterator *iter)
265	{
266	kfree(iter);
267	}
268
269	/**
270	* gcov_iter_get_info - return profiling data set for given file iterator
271	* @iter: file iterator
272	*/
273	struct gcov_info gcov_iter_get_info(struct gcov_iterator iter)
274	{
275	return iter->info;
276	}
277
278	/**
279	* gcov_iter_start - reset file iterator to starting position
280	* @iter: file iterator
281	*/
282	void gcov_iter_start(struct gcov_iterator *iter)
283	{
284	int i;
285
286	iter->record = 0;
287	iter->function = 0;
288	iter->type = 0;
289	iter->count = 0;
290	iter->num_types = 0;
291	for (i = 0; i < GCOV_COUNTERS; i++) {
292	if (counter_active(iter->info, i)) {
293	iter->type_info[iter->num_types].ctr_type = i;
294	iter->type_info[iter->num_types++].offset = 0;
295	}
296	}
297	}
298
299	/* Mapping of logical record number to actual file content. */
300	#define RECORD_FILE_MAGIC 0
301	#define RECORD_GCOV_VERSION 1
302	#define RECORD_TIME_STAMP 2
303	#define RECORD_FUNCTION_TAG 3
304	#define RECORD_FUNCTON_TAG_LEN 4
305	#define RECORD_FUNCTION_IDENT 5
306	#define RECORD_FUNCTION_CHECK 6
307	#define RECORD_COUNT_TAG 7
308	#define RECORD_COUNT_LEN 8
309	#define RECORD_COUNT 9
310
311	/**
312	* gcov_iter_next - advance file iterator to next logical record
313	* @iter: file iterator
314	*
315	* Return zero if new position is valid, non-zero if iterator has reached end.
316	*/
317	int gcov_iter_next(struct gcov_iterator *iter)
318	{
319	switch (iter->record) {
320	case RECORD_FILE_MAGIC:
321	case RECORD_GCOV_VERSION:
322	case RECORD_FUNCTION_TAG:
323	case RECORD_FUNCTON_TAG_LEN:
324	case RECORD_FUNCTION_IDENT:
325	case RECORD_COUNT_TAG:
326	/* Advance to next record */
327	iter->record++;
328	break;
329	case RECORD_COUNT:
330	/* Advance to next count */
331	iter->count++;
332	/* fall through */
333	case RECORD_COUNT_LEN:
334	if (iter->count < get_func(iter)->n_ctrs[iter->type]) {
335	iter->record = 9;
336	break;
337	}
338	/* Advance to next counter type */
339	get_type(iter)->offset += iter->count;
340	iter->count = 0;
341	iter->type++;
342	/* fall through */
343	case RECORD_FUNCTION_CHECK:
344	if (iter->type < iter->num_types) {
345	iter->record = 7;
346	break;
347	}
348	/* Advance to next function */
349	iter->type = 0;
350	iter->function++;
351	/* fall through */
352	case RECORD_TIME_STAMP:
353	if (iter->function < iter->info->n_functions)
354	iter->record = 3;
355	else
356	iter->record = -1;
357	break;
358	}
359	/* Check for EOF. */
360	if (iter->record == -1)
361	return -EINVAL;
362	else
363	return 0;
364	}
365
366	/**
367	* seq_write_gcov_u32 - write 32 bit number in gcov format to seq_file
368	* @seq: seq_file handle
369	* @v: value to be stored
370	*
371	* Number format defined by gcc: numbers are recorded in the 32 bit
372	* unsigned binary form of the endianness of the machine generating the
373	* file.
374	*/
375	static int seq_write_gcov_u32(struct seq_file *seq, u32 v)
376	{
377	return seq_write(seq, &v, sizeof(v));
378	}
379
380	/**
381	* seq_write_gcov_u64 - write 64 bit number in gcov format to seq_file
382	* @seq: seq_file handle
383	* @v: value to be stored
384	*
385	* Number format defined by gcc: numbers are recorded in the 32 bit
386	* unsigned binary form of the endianness of the machine generating the
387	* file. 64 bit numbers are stored as two 32 bit numbers, the low part
388	* first.
389	*/
390	static int seq_write_gcov_u64(struct seq_file *seq, u64 v)
391	{
392	u32 data[2];
393
394	data[0] = (v & 0xffffffffUL);
395	data[1] = (v >> 32);
396	return seq_write(seq, data, sizeof(data));
397	}
398
399	/**
400	* gcov_iter_write - write data for current pos to seq_file
401	* @iter: file iterator
402	* @seq: seq_file handle
403	*
404	* Return zero on success, non-zero otherwise.
405	*/
406	int gcov_iter_write(struct gcov_iterator iter, struct seq_file seq)
407	{
408	int rc = -EINVAL;
409
410	switch (iter->record) {
411	case RECORD_FILE_MAGIC:
412	rc = seq_write_gcov_u32(seq, GCOV_DATA_MAGIC);
413	break;
414	case RECORD_GCOV_VERSION:
415	rc = seq_write_gcov_u32(seq, iter->info->version);
416	break;
417	case RECORD_TIME_STAMP:
418	rc = seq_write_gcov_u32(seq, iter->info->stamp);
419	break;
420	case RECORD_FUNCTION_TAG:
421	rc = seq_write_gcov_u32(seq, GCOV_TAG_FUNCTION);
422	break;
423	case RECORD_FUNCTON_TAG_LEN:
424	rc = seq_write_gcov_u32(seq, 2);
425	break;
426	case RECORD_FUNCTION_IDENT:
427	rc = seq_write_gcov_u32(seq, get_func(iter)->ident);
428	break;
429	case RECORD_FUNCTION_CHECK:
430	rc = seq_write_gcov_u32(seq, get_func(iter)->checksum);
431	break;
432	case RECORD_COUNT_TAG:
433	rc = seq_write_gcov_u32(seq,
434	GCOV_TAG_FOR_COUNTER(get_type(iter)->ctr_type));
435	break;
436	case RECORD_COUNT_LEN:
437	rc = seq_write_gcov_u32(seq,
438	get_func(iter)->n_ctrs[iter->type] * 2);
439	break;
440	case RECORD_COUNT:
441	rc = seq_write_gcov_u64(seq,
442	iter->info->counts[iter->type].
443	values[iter->count + get_type(iter)->offset]);
444	break;
445	}
446	return rc;
447	}