Re: m68k structure packing

[Peter Barada <pbarada@wavemark.com>]

>> If you have a short in the struct:
>
>> struct {
>> 	short b;
>> 	char a;
>> } z, list[10];
>
>> then sizeof(z) could be 3 but is 4 due to alignment requirements(i.e
>> malloc(n*sizeof(z))) and sizeof(list) is 40.
>
>Is this fact, or theory?  On the sparc, which is unaffacted by my
>change, with -fpack-struct we get 3 bytes.

If you pack the structure on any hardware with strict alignment then
you have to access any non-byte element using ONLY byte accesses since
you can not assume the alignment of the address of the start of the structure.
Unfortunately on the 68k this produces some really slow code. Ex: 

struct foo {
	char c;
	short b;
} *p;

When foo is not packed, the size is 4, and the offset to b is 2.
compiling p->b += 1 when foo is not packed gives:

; for sake of theexample, I'll load p->b into a register.
;
move.l	 p,a0		; load p into a0
move.w	 2(a0),d0	; load short 2 off of a0 into d0 (ofset to b)
addq.w	 #1,d0		; increment d0 as a word
move.w	 d0,2(a0)	; store short d0 2 off of a0

This works since it is assumed thant any pointer to the structure is even.

When foo is packed, the size is 3, and offset to b is 1.
To compile p->b += 1 when foo is packed requires:

move.l	 p,a0		; load p into a0
move.b	 1(a0),d0	; load the high byte of p->b into d0
lsl.w	 #8,d0		; shift left into the high byte
move.b	 2(a0),d0	; load the low byte of p->b into d0
addq.w	 #1,d0		; increment as a word
move.b	 d0,2(a0)	; store low byte
lsr.w	 #8,d0		; shift high byte into low byte
move.b	 d0,1(a0)	; store high byte

Obviously this takes more instructions, and many more clock cycles.
On the 68000 it takes 4 clocks for each bit shift, so in this code the
shifts alone take up 64 clocks.  I don't think the tradeoff is worth
it here.

On other processors that allow unaligned acces, then the code is the
same in either case, and the only hit is having to double cycle the
bus.

>Should the above code fail at runtime?  (You have to have a
>STRICT_ALIGNMENT machine, pack a structure, and you may have to use
>int or long or float or double to make it fail).  If not, should we
>make it work by aligning it or by requiring what the pointer points to
>is a packed short, then on dereference of a pointer to a packed short,
>we could know to do byte accesses.

Again it all depends. If you pack and use short accesses, then yes I
would expect a SIGBUS error on the short load instruction. If you can
pack it and the compiler can produce code that uses only byte
accesses, then the bloated code will go dog slow but not SIGBUS.

If you want packed structures then they should be sized up to a short, and
anything that is not a char in a packed struct should be aligned on a
short boundary(BIGGEST_ALIGNMENT). But this is what happens on the 68k
anyway.

-- 
Peter Barada				pbarada@wavemark.com
Wizard					617-270-7098 x1226
WaveMark Technologies, Inc.		617-270-0193 (fax)

"Real men know that you should never attempt to accomplish with words
what you can do with a flame thrower" --Bruce Ferstein