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


#define __KERNEL__

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

#include <linux/compiler.h>

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

// Useful outsize __KERNEL__. Not used here because inline is already redefined.
#define force_inline inline __attribute__((always_inline))

/* Calculate the offset needed to align the type */
static 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 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 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 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 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 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 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 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);

	/* Realign on arch size */
	locsize = sizeof(void *);
	size += ltt_align(size, locsize);

	return size;
}

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