[lttv.git] / genevent-new / gentest.c


#include <assert.h>
#include <sys/types.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>

#define min(a,b) (((a)<(b))?a:b)
#define max(a,b) (((a)>(b))?a:b)
#define BUG_ON(a) assert(!(a))

#define force_inline inline __attribute__((always_inline))

/* Calculate the offset needed to align the type */
static force_inline unsigned int ltt_align(size_t align_drift,
																		 size_t size_of_type)
{
	size_t alignment = min(sizeof(void*), size_of_type);

	return ((alignment - align_drift) & (alignment-1));
}


/* TEMPLATE */

enum lttng_tasklet_priority {
	LTTNG_LOW,
	LTTNG_HIGH,
};

enum lttng_irq_mode {
	LTTNG_user,
	LTTNG_kernel,
};

struct lttng_mystruct2 {
	unsigned int irq_id;
	enum lttng_irq_mode mode;
	//struct lttng_mystruct teststr1;
};


static force_inline size_t lttng_get_size_mystruct2(
		struct lttng_mystruct2 * obj)
{
	size_t size=0, locsize;
	
	locsize = sizeof(unsigned int);
	size += ltt_align(size, locsize) + locsize;
	
	locsize = sizeof(enum lttng_irq_mode);
	size += ltt_align(size, locsize) + locsize;

	BUG_ON(sizeof(struct lttng_mystruct2) != size);

	return sizeof(struct lttng_mystruct2);
}

static force_inline size_t lttng_get_alignment_mystruct2(
		struct lttng_mystruct2 *obj)
{
	size_t align=0, localign;
	
	localign = sizeof(unsigned int);
	align = max(align, localign);
	
	localign = sizeof(enum lttng_irq_mode);
	align = max(align, localign);

	return align;
}

static force_inline void lttng_write_mystruct2(
		void **to_base,
		size_t *to,
		void **from,
		size_t *len,
		struct lttng_mystruct2 *obj)
{
	size_t align, size;

	align = lttng_get_alignment_mystruct2(obj);
	size = lttng_get_size_mystruct2(obj);

	if(*len == 0) {
		*to += ltt_align(*to, align);	/* align output */
	} else {
		*len += ltt_align(*to+*len, align);	/* C alignment, ok to do a memcpy of it */
	}
	
	*len += size;
}


#define LTTNG_ARRAY_SIZE_mystruct_myarray 10
typedef uint64_t lttng_array_mystruct_myarray[LTTNG_ARRAY_SIZE_mystruct_myarray];

static force_inline size_t lttng_get_size_array_mystruct_myarray(
		lttng_array_mystruct_myarray obj)
{
	size_t size=0, locsize;
	
	locsize = sizeof(uint64_t);
	/* ltt_align == 0 always*/
	//size += ltt_align(size, locsize) + (LTTNG_ARRAY_SIZE_mystruct_myarray * locsize);
	BUG_ON(ltt_align(size, locsize) != 0);
	size += LTTNG_ARRAY_SIZE_mystruct_myarray * locsize;

	BUG_ON(size != LTTNG_ARRAY_SIZE_mystruct_myarray * sizeof(uint64_t));

	return size;
}

static force_inline size_t lttng_get_alignment_array_mystruct_myarray(
		lttng_array_mystruct_myarray obj)
{
	size_t align=0, localign;
	
	localign = sizeof(uint64_t);
	align = max(align, localign);

	return align;
}


static force_inline void lttng_write_array_mystruct_myarray(
		void **to_base,
		size_t *to,
		void **from,
		size_t *len,
		lttng_array_mystruct_myarray obj)
{
	size_t align, size;
	
	align = lttng_get_alignment_array_mystruct_myarray(obj);
	size = lttng_get_size_array_mystruct_myarray(obj);

	if(*len == 0) {
		*to += ltt_align(*to, align);	/* align output */
	} else {
		*len += ltt_align(*to+*len, align);	/* C alignment, ok to do a memcpy of it */
	}
	
	*len += size;
}


typedef struct lttng_sequence_mystruct_mysequence lttng_sequence_mystruct_mysequence;
struct lttng_sequence_mystruct_mysequence {
	unsigned int len;
	double *array;
};


static force_inline size_t lttng_get_size_sequence_mystruct_mysequence(
																 lttng_sequence_mystruct_mysequence *obj)
{
	size_t size=0, locsize;
	
	locsize = sizeof(unsigned int);
	size += ltt_align(size, locsize) + locsize;

	locsize = sizeof(double);
	size += ltt_align(size, locsize) + (obj->len * locsize);

	return size;
}

static force_inline size_t lttng_get_alignment_sequence_mystruct_mysequence(
																 lttng_sequence_mystruct_mysequence *obj)
{
	size_t align=0, localign;
	
	localign = sizeof(unsigned int);
	align = max(align, localign);

	localign = sizeof(double);
	align = max(align, localign);

	return align;
}


static force_inline void lttng_write_sequence_mystruct_mysequence(
		void **to_base,
		size_t *to,
		void **from,
		size_t *len,
		lttng_sequence_mystruct_mysequence *obj)
{
	size_t align;
	void *varfrom;
	size_t varlen=0;
	
	/* Flush pending memcpy */
	if(*len != 0) {
		memcpy(*to_base+*to, *from, *len);
		*to += *len;
		*len = 0;
	}

	align = lttng_get_alignment_sequence_mystruct_mysequence(obj);
	//no need size = lttng_get_size_sequence_mystruct_mysequence(obj);

	/* Align output */
	*to += ltt_align(*to, align);	/* *len = 0 in this function */
	
	/* Copy members */
	*to += ltt_align(*to, sizeof(unsigned int));
	varfrom = &obj->len;
	varlen += sizeof(unsigned int);
	memcpy(*to_base+*to, varfrom, varlen);
	*to += varlen;
	varlen = 0;

	*to += ltt_align(*to, sizeof(double));
	varfrom = obj->array;
	varlen += obj->len * sizeof(double);
	memcpy(*to_base+*to, varfrom, varlen);
	*to += varlen;
	varlen = 0;

	/* Realign the *to_base on arch size, set *to to 0 */
	*to = ltt_align(*to, sizeof(void *));
	*to_base = *to_base+*to;
	*to = 0;

	/* Put source *from just after the C sequence */
	*from = obj+1;
}


union lttng_mystruct_myunion {
	double myfloat;
	unsigned long myulong;
};


static force_inline size_t lttng_get_size_mystruct_myunion(
																 union lttng_mystruct_myunion *obj)
{
	size_t size=0, locsize;
	
	locsize = sizeof(double);
	size = max(size, locsize);

	locsize = sizeof(unsigned long);
	size = max(size, locsize);

	BUG_ON(size != sizeof(union lttng_mystruct_myunion));

	return size;
}


static force_inline size_t lttng_get_alignment_mystruct_myunion(
																 union lttng_mystruct_myunion *obj)
{
	size_t align=0, localign;
	
	localign = sizeof(double);
	align = max(align, localign);

	localign = sizeof(unsigned long);
	align = max(align, localign);

	return align;
}


static force_inline void lttng_write_mystruct_myunion(
		void **to_base,
		size_t *to,
		void **from,
		size_t *len,
		union lttng_mystruct_myunion *obj)
{
	size_t align, size;
	
	align = lttng_get_alignment_mystruct_myunion(obj);
	size = lttng_get_size_mystruct_myunion(obj);

	if(*len == 0) {
		*to += ltt_align(*to, align);	/* align output */
	} else {
		*len += ltt_align(*to+*len, align);	/* C alignment, ok to do a memcpy of it */
	}
	
	*len += size;
}


struct lttng_mystruct {
	unsigned int irq_id;
	enum lttng_irq_mode mode;
	struct lttng_mystruct2 teststr;
	lttng_array_mystruct_myarray myarray;
	lttng_sequence_mystruct_mysequence mysequence;
	union lttng_mystruct_myunion myunion;
};

static force_inline size_t lttng_get_size_mystruct(
		struct lttng_mystruct *obj)
{
	size_t size=0, locsize, localign;
	
	locsize = sizeof(unsigned int);
	size += ltt_align(size, locsize) + locsize;
	
	locsize = sizeof(enum lttng_irq_mode);
	size += ltt_align(size, locsize) + locsize;

	localign = lttng_get_alignment_mystruct2(&obj->teststr);
	locsize = lttng_get_size_mystruct2(&obj->teststr);
	size += ltt_align(size, localign) + locsize;
	
	localign = lttng_get_alignment_array_mystruct_myarray(obj->myarray);
	locsize = lttng_get_size_array_mystruct_myarray(obj->myarray);
	size += ltt_align(size, localign) + locsize;
	
	localign = lttng_get_alignment_sequence_mystruct_mysequence(&obj->mysequence);
	locsize = lttng_get_size_sequence_mystruct_mysequence(&obj->mysequence);
	size += ltt_align(size, localign) + locsize;
	
	localign = lttng_get_alignment_mystruct_myunion(&obj->myunion);
	locsize = lttng_get_size_mystruct_myunion(&obj->myunion);
	size += ltt_align(size, localign) + locsize;

	return size;
}


static force_inline size_t lttng_get_alignment_mystruct(
		struct lttng_mystruct *obj)
{
	size_t align=0, localign;
	
	localign = sizeof(unsigned int);
	align = max(align, localign);
	
	localign = sizeof(enum lttng_irq_mode);
	align = max(align, localign);

	localign = lttng_get_alignment_mystruct2(&obj->teststr);
	align = max(align, localign);
	
	localign = lttng_get_alignment_array_mystruct_myarray(obj->myarray);
	align = max(align, localign);
	
	localign = lttng_get_alignment_sequence_mystruct_mysequence(&obj->mysequence);
	align = max(align, localign);
	
	localign = lttng_get_alignment_mystruct_myunion(&obj->myunion);
	align = max(align, localign);

	return align;
}

static force_inline void lttng_write_mystruct(
		void **to_base,
		size_t *to,
		void **from,
		size_t *len,
		struct lttng_mystruct *obj)
{
	size_t align, size;
	
	align = lttng_get_alignment_mystruct(obj);
	// no need : contains variable size fields.
	// locsize = lttng_get_size_mystruct(obj);

	if(*len == 0) {
		*to += ltt_align(*to, align);	/* align output */
	} else {
		*len += ltt_align(*to+*len, align);	/* C alignment, ok to do a memcpy of it */
	}
	
	/* Contains variable sized fields : must explode the structure */
	
	size = sizeof(unsigned int);
	size += ltt_align(*to+*len, size) + size;
	*len += size;
	
	size = sizeof(enum lttng_irq_mode);
	size += ltt_align(*to+*len, size) + size;
	*len += size;

	lttng_write_mystruct2(to_base, to, from, len, &obj->teststr);

	lttng_write_array_mystruct_myarray(to_base, to, from, len, obj->myarray);

	/* Variable length field */
	lttng_write_sequence_mystruct_mysequence(to_base, to, from, len, &obj->mysequence);
	*to = 0;	/* Force the compiler to know it's 0 */
	/* After this previous write, we are sure that *to is 0, and *to_base is
	 * aligned on the architecture size : to rest of alignment will be calculated
	 * statically. */

	lttng_write_mystruct_myunion(to_base, to, from, len, &obj->myunion);

	/* Don't forget to flush last write..... */
}


//void main()
void test()
{
	struct lttng_mystruct test;
	test.mysequence.len = 20;
	test.mysequence.array = malloc(20);

	size_t size = lttng_get_size_mystruct(&test);
	size_t align = lttng_get_alignment_mystruct(&test);

	void *buf = malloc(align + size);
	void *to_base = buf;	/* the buffer is allocated on arch_size alignment */
	size_t to = 0;
	void *from = &test;
	size_t len = 0;

	lttng_write_mystruct(&to_base, &to, &from, &len, &test);
	/* Final flush */
	/* Flush pending memcpy */
	if(len != 0) {
		memcpy(to_base+to, from, len);
		to += len;
		from += len;
		len = 0;
	}
	
	free(test.mysequence.array);
	free(buf);
}
Commit	Line	Data
6ef4987c	1
	2	#include <assert.h>
	3	#include <sys/types.h>
	4	#include <stdint.h>
	5	#include <stdlib.h>
3e090fd3	6	#include <string.h>
6ef4987c	7
	8	#define min(a,b) (((a)<(b))?a:b)
	9	#define max(a,b) (((a)>(b))?a:b)
	10	#define BUG_ON(a) assert(!(a))
	11
1a42a214	12	#define force_inline inline __attribute__((always_inline))
1a42a214	13
6ef4987c	14	/* Calculate the offset needed to align the type */
1a42a214	15	static force_inline unsigned int ltt_align(size_t align_drift,
6ef4987c	16	size_t size_of_type)
	17	{
	18	size_t alignment = min(sizeof(void*), size_of_type);
	19
	20	return ((alignment - align_drift) & (alignment-1));
	21	}
	22
	23
	24	/* TEMPLATE */
	25
	26	enum lttng_tasklet_priority {
	27	LTTNG_LOW,
	28	LTTNG_HIGH,
	29	};
	30
	31	enum lttng_irq_mode {
	32	LTTNG_user,
	33	LTTNG_kernel,
	34	};
	35
	36	struct lttng_mystruct2 {
	37	unsigned int irq_id;
	38	enum lttng_irq_mode mode;
	39	//struct lttng_mystruct teststr1;
	40	};
	41
	42
1a42a214	43	static force_inline size_t lttng_get_size_mystruct2(
257d03bc	44	struct lttng_mystruct2 * obj)
6ef4987c	45	{
	46	size_t size=0, locsize;
	47
	48	locsize = sizeof(unsigned int);
	49	size += ltt_align(size, locsize) + locsize;
	50
	51	locsize = sizeof(enum lttng_irq_mode);
	52	size += ltt_align(size, locsize) + locsize;
	53
	54	BUG_ON(sizeof(struct lttng_mystruct2) != size);
	55
	56	return sizeof(struct lttng_mystruct2);
	57	}
	58
1a42a214	59	static force_inline size_t lttng_get_alignment_mystruct2(
6ef4987c	60	struct lttng_mystruct2 *obj)
	61	{
	62	size_t align=0, localign;
	63
	64	localign = sizeof(unsigned int);
	65	align = max(align, localign);
	66
	67	localign = sizeof(enum lttng_irq_mode);
	68	align = max(align, localign);
	69
	70	return align;
	71	}
	72
1a42a214	73	static force_inline void lttng_write_mystruct2(
1c341713	74	void **to_base,
257d03bc	75	size_t *to,
6ef4987c	76	void **from,
	77	size_t *len,
	78	struct lttng_mystruct2 *obj)
	79	{
3e090fd3	80	size_t align, size;
6ef4987c	81
	82	align = lttng_get_alignment_mystruct2(obj);
	83	size = lttng_get_size_mystruct2(obj);
	84
	85	if(*len == 0) {
1c341713	86	to += ltt_align(to, align); /* align output */
6ef4987c	87	} else {
1c341713	88	len += ltt_align(to+len, align); / C alignment, ok to do a memcpy of it */
6ef4987c	89	}
	90
	91	*len += size;
	92	}
	93
	94
	95
	96	#define LTTNG_ARRAY_SIZE_mystruct_myarray 10
	97	typedef uint64_t lttng_array_mystruct_myarray[LTTNG_ARRAY_SIZE_mystruct_myarray];
	98
1a42a214	99	static force_inline size_t lttng_get_size_array_mystruct_myarray(
6ef4987c	100	lttng_array_mystruct_myarray obj)
	101	{
	102	size_t size=0, locsize;
	103
	104	locsize = sizeof(uint64_t);
	105	/* ltt_align == 0 always*/
	106	//size += ltt_align(size, locsize) + (LTTNG_ARRAY_SIZE_mystruct_myarray * locsize);
	107	BUG_ON(ltt_align(size, locsize) != 0);
	108	size += LTTNG_ARRAY_SIZE_mystruct_myarray * locsize;
	109
	110	BUG_ON(size != LTTNG_ARRAY_SIZE_mystruct_myarray * sizeof(uint64_t));
	111
	112	return size;
	113	}
	114
1a42a214	115	static force_inline size_t lttng_get_alignment_array_mystruct_myarray(
6ef4987c	116	lttng_array_mystruct_myarray obj)
	117	{
	118	size_t align=0, localign;
	119
	120	localign = sizeof(uint64_t);
	121	align = max(align, localign);
	122
	123	return align;
	124	}
	125
	126
1a42a214	127	static force_inline void lttng_write_array_mystruct_myarray(
1c341713	128	void **to_base,
257d03bc	129	size_t *to,
6ef4987c	130	void **from,
	131	size_t *len,
	132	lttng_array_mystruct_myarray obj)
	133	{
1c341713	134	size_t align, size;
6ef4987c	135
	136	align = lttng_get_alignment_array_mystruct_myarray(obj);
	137	size = lttng_get_size_array_mystruct_myarray(obj);
	138
	139	if(*len == 0) {
1c341713	140	to += ltt_align(to, align); /* align output */
6ef4987c	141	} else {
1c341713	142	len += ltt_align(to+len, align); / C alignment, ok to do a memcpy of it */
6ef4987c	143	}
	144
	145	*len += size;
	146	}
	147
	148
	149	typedef struct lttng_sequence_mystruct_mysequence lttng_sequence_mystruct_mysequence;
	150	struct lttng_sequence_mystruct_mysequence {
	151	unsigned int len;
	152	double *array;
	153	};
	154
	155
1a42a214	156	static force_inline size_t lttng_get_size_sequence_mystruct_mysequence(
6ef4987c	157	lttng_sequence_mystruct_mysequence *obj)
	158	{
	159	size_t size=0, locsize;
	160
	161	locsize = sizeof(unsigned int);
	162	size += ltt_align(size, locsize) + locsize;
	163
	164	locsize = sizeof(double);
	165	size += ltt_align(size, locsize) + (obj->len * locsize);
	166
	167	return size;
	168	}
	169
1a42a214	170	static force_inline size_t lttng_get_alignment_sequence_mystruct_mysequence(
6ef4987c	171	lttng_sequence_mystruct_mysequence *obj)
	172	{
	173	size_t align=0, localign;
	174
	175	localign = sizeof(unsigned int);
	176	align = max(align, localign);
	177
	178	localign = sizeof(double);
	179	align = max(align, localign);
	180
	181	return align;
	182	}
	183
	184
1a42a214	185	static force_inline void lttng_write_sequence_mystruct_mysequence(
1c341713	186	void **to_base,
257d03bc	187	size_t *to,
6ef4987c	188	void **from,
	189	size_t *len,
	190	lttng_sequence_mystruct_mysequence *obj)
	191	{
257d03bc	192	size_t align;
6ef4987c	193	void *varfrom;
	194	size_t varlen=0;
	195
	196	/* Flush pending memcpy */
	197	if(*len != 0) {
1c341713	198	memcpy(to_base+to, from, len);
6ef4987c	199	to += len;
	200	*len = 0;
	201	}
	202
	203	align = lttng_get_alignment_sequence_mystruct_mysequence(obj);
	204	//no need size = lttng_get_size_sequence_mystruct_mysequence(obj);
	205
	206	/* Align output */
1c341713	207	to += ltt_align(to, align); /* len = 0 in this function /
6ef4987c	208
6ef4987c	209	/* Copy members */
1c341713	210	to += ltt_align(to, sizeof(unsigned int));
6ef4987c	211	varfrom = &obj->len;
6ef4987c	212	varlen += sizeof(unsigned int);
1c341713	213	memcpy(to_base+to, varfrom, varlen);
1c341713	214	*to += varlen;
6ef4987c	215	varlen = 0;
6ef4987c	216
1c341713	217	to += ltt_align(to, sizeof(double));
6ef4987c	218	varfrom = obj->array;
6ef4987c	219	varlen += obj->len * sizeof(double);
1c341713	220	memcpy(to_base+to, varfrom, varlen);
1c341713	221	*to += varlen;
6ef4987c	222	varlen = 0;
6ef4987c	223
1c341713	224	/* Realign the to_base on arch size, set to to 0 */
	225	to = ltt_align(to, sizeof(void *));
	226	to_base = to_base+*to;
	227	*to = 0;
a6cf4981	228
6ef4987c	229	/* Put source from just after the C sequence /
	230	*from = obj+1;
	231	}
	232
	233
	234
	235	union lttng_mystruct_myunion {
	236	double myfloat;
	237	unsigned long myulong;
	238	};
	239
	240
1a42a214	241	static force_inline size_t lttng_get_size_mystruct_myunion(
6ef4987c	242	union lttng_mystruct_myunion *obj)
	243	{
	244	size_t size=0, locsize;
	245
	246	locsize = sizeof(double);
	247	size = max(size, locsize);
	248
	249	locsize = sizeof(unsigned long);
	250	size = max(size, locsize);
	251
	252	BUG_ON(size != sizeof(union lttng_mystruct_myunion));
	253
	254	return size;
	255	}
	256
	257
1a42a214	258	static force_inline size_t lttng_get_alignment_mystruct_myunion(
6ef4987c	259	union lttng_mystruct_myunion *obj)
	260	{
	261	size_t align=0, localign;
	262
	263	localign = sizeof(double);
	264	align = max(align, localign);
	265
	266	localign = sizeof(unsigned long);
	267	align = max(align, localign);
	268
	269	return align;
	270	}
	271
	272
1a42a214	273	static force_inline void lttng_write_mystruct_myunion(
1c341713	274	void **to_base,
257d03bc	275	size_t *to,
6ef4987c	276	void **from,
	277	size_t *len,
	278	union lttng_mystruct_myunion *obj)
	279	{
1c341713	280	size_t align, size;
6ef4987c	281
	282	align = lttng_get_alignment_mystruct_myunion(obj);
	283	size = lttng_get_size_mystruct_myunion(obj);
	284
	285	if(*len == 0) {
1c341713	286	to += ltt_align(to, align); /* align output */
6ef4987c	287	} else {
1c341713	288	len += ltt_align(to+len, align); / C alignment, ok to do a memcpy of it */
6ef4987c	289	}
	290
	291	*len += size;
	292	}
	293
	294
	295	struct lttng_mystruct {
	296	unsigned int irq_id;
	297	enum lttng_irq_mode mode;
	298	struct lttng_mystruct2 teststr;
	299	lttng_array_mystruct_myarray myarray;
	300	lttng_sequence_mystruct_mysequence mysequence;
	301	union lttng_mystruct_myunion myunion;
	302	};
	303
1a42a214	304	static force_inline size_t lttng_get_size_mystruct(
6ef4987c	305	struct lttng_mystruct *obj)
	306	{
	307	size_t size=0, locsize, localign;
	308
	309	locsize = sizeof(unsigned int);
	310	size += ltt_align(size, locsize) + locsize;
	311
	312	locsize = sizeof(enum lttng_irq_mode);
	313	size += ltt_align(size, locsize) + locsize;
	314
	315	localign = lttng_get_alignment_mystruct2(&obj->teststr);
	316	locsize = lttng_get_size_mystruct2(&obj->teststr);
	317	size += ltt_align(size, localign) + locsize;
	318
	319	localign = lttng_get_alignment_array_mystruct_myarray(obj->myarray);
	320	locsize = lttng_get_size_array_mystruct_myarray(obj->myarray);
	321	size += ltt_align(size, localign) + locsize;
	322
	323	localign = lttng_get_alignment_sequence_mystruct_mysequence(&obj->mysequence);
	324	locsize = lttng_get_size_sequence_mystruct_mysequence(&obj->mysequence);
	325	size += ltt_align(size, localign) + locsize;
	326
	327	localign = lttng_get_alignment_mystruct_myunion(&obj->myunion);
	328	locsize = lttng_get_size_mystruct_myunion(&obj->myunion);
	329	size += ltt_align(size, localign) + locsize;
	330
	331	return size;
	332	}
	333
	334
1a42a214	335	static force_inline size_t lttng_get_alignment_mystruct(
6ef4987c	336	struct lttng_mystruct *obj)
	337	{
	338	size_t align=0, localign;
	339
	340	localign = sizeof(unsigned int);
	341	align = max(align, localign);
	342
	343	localign = sizeof(enum lttng_irq_mode);
	344	align = max(align, localign);
	345
	346	localign = lttng_get_alignment_mystruct2(&obj->teststr);
	347	align = max(align, localign);
	348
	349	localign = lttng_get_alignment_array_mystruct_myarray(obj->myarray);
	350	align = max(align, localign);
	351
	352	localign = lttng_get_alignment_sequence_mystruct_mysequence(&obj->mysequence);
	353	align = max(align, localign);
	354
	355	localign = lttng_get_alignment_mystruct_myunion(&obj->myunion);
	356	align = max(align, localign);
	357
	358	return align;
	359	}
	360
1a42a214	361	static force_inline void lttng_write_mystruct(
1c341713	362	void **to_base,
257d03bc	363	size_t *to,
6ef4987c	364	void **from,
	365	size_t *len,
	366	struct lttng_mystruct *obj)
	367	{
1c341713	368	size_t align, size;
6ef4987c	369
	370	align = lttng_get_alignment_mystruct(obj);
	371	// no need : contains variable size fields.
	372	// locsize = lttng_get_size_mystruct(obj);
	373
	374	if(*len == 0) {
257d03bc	375	to += ltt_align(to, align); /* align output */
6ef4987c	376	} else {
257d03bc	377	len += ltt_align(to+len, align); / C alignment, ok to do a memcpy of it */
6ef4987c	378	}
	379
	380	/* Contains variable sized fields : must explode the structure */
	381
1c341713	382	size = sizeof(unsigned int);
	383	size += ltt_align(to+len, size) + size;
	384	*len += size;
6ef4987c	385
1c341713	386	size = sizeof(enum lttng_irq_mode);
	387	size += ltt_align(to+len, size) + size;
	388	*len += size;
6ef4987c	389
1c341713	390	lttng_write_mystruct2(to_base, to, from, len, &obj->teststr);
6ef4987c	391
1c341713	392	lttng_write_array_mystruct_myarray(to_base, to, from, len, obj->myarray);
6ef4987c	393
6ef4987c	394	/* Variable length field */
1c341713	395	lttng_write_sequence_mystruct_mysequence(to_base, to, from, len, &obj->mysequence);
a6cf4981	396	to = 0; / Force the compiler to know it's 0 */
1c341713	397	/* After this previous write, we are sure that to is 0, and to_base is
	398	* aligned on the architecture size : to rest of alignment will be calculated
	399	* statically. */
	400
1c341713	401	lttng_write_mystruct_myunion(to_base, to, from, len, &obj->myunion);
6ef4987c	402
	403	/* Don't forget to flush last write..... */
	404	}
	405
	406
	407
	408
	409
	410
257d03bc	411	//void main()
257d03bc	412	void test()
6ef4987c	413	{
	414	struct lttng_mystruct test;
	415	test.mysequence.len = 20;
	416	test.mysequence.array = malloc(20);
	417
	418	size_t size = lttng_get_size_mystruct(&test);
	419	size_t align = lttng_get_alignment_mystruct(&test);
	420
	421	void *buf = malloc(align + size);
1c341713	422	void to_base = buf; / the buffer is allocated on arch_size alignment */
257d03bc	423	size_t to = 0;
6ef4987c	424	void *from = &test;
	425	size_t len = 0;
	426
1c341713	427	lttng_write_mystruct(&to_base, &to, &from, &len, &test);
6ef4987c	428	/* Final flush */
	429	/* Flush pending memcpy */
	430	if(len != 0) {
1c341713	431	memcpy(to_base+to, from, len);
6ef4987c	432	to += len;
	433	from += len;
	434	len = 0;
	435	}
	436
	437	free(test.mysequence.array);
	438	free(buf);
	439	}