Newbie: arm-elf-gcc generated asm question

Check that R2 is word aligned. If it is not, the loaded value will be rotated.

Your address seems to have bit 0 set. If this is the case -- the compiler is doing something really nasty.

HTH, Vadim

but

Thanks for the advice - the variable being assigned is actually part of a structure (I simplified the example). Ensuring the variable started on a

Is there a way of forcing all alignment onto four byte boundaries? I've looked through the GCC and LD docs and can find switches for other targets, but not the ARM.

Thanks again!

Compiler does this automatically. If you, say, have the structure

struct { uint8_t one; uint32_t two; } foo;

then foo.two will always be word aligned.

What are your trying to do? If you would post a snippet of your data structure it might be easier to help.

Vadim

Are you using the compiler switch '-fpack-struct' ? If so you must manually ensure the correct padding is used.

Andy

The compiler will properly align all variables and structure fields unless you tell it to do otherwise.

IOW, you had to write code that does something bad to get such an alignment problem (most likely typecasting a pointer or using a packed struct). You're probably better off not doing "bad" things rather than forcing the alignment of everything to a word boundary. If you explain what it is you're actually trying to do, somebody can show you how to do it the "good" way.

Hi again,

The structure is like this:

struct { uint8 aByte; uint8 aByteArray[ 64 ]; } foo;

Hence my problem - the aByteArray is used as a generic buffer that can hold anything. I was putting 32bit words into it, and as a byte array there is no way of the compiler knowing that I wanted it 32bit aligned - a bit silly now I come to look at it but sometimes it takes somebody else to point out you are doing something daft ;-)

In answer to the other question: I'm not using -fpack-struct.

Thanks again.

You probably need to use memcpy() to copy data to/from your buffer. You could force alignment of the beginning of the array, but things will still fall apart if you use type-punned pointers to put multiple things of differing sizes into the buffer.

Fine, this explains why the value you read is rotated right by one byte.

You might probably need to do something like

struct { uint8 aByte; union { uint32 aWordArray[16]; uint8 aByteArray[64]; } u; } foo;

In this case foo.u.aWordArray[x] is guaranteed to be word aligned, as the whole union will be.

HTH,

Vadim

There seems to be something a bit kludgy about what I'm about to suggest (I'm not sure why, except there's this Bogus_Variable defined but never used), but could you use a union of a 4-byte 'bogus' unused varuable with the aByteArray, to make the compiler align it? Like this:

struct { uint8 aByte; union { uint32 Bogus_Variable; uint8 aByteArray[ 64 ]; } } foo;

There seems like there ought to be another way to do it, perhaps with a compiler-specific #pragma, but this should work with any compiler.

-----

I think you can force gcc to align the buffer using:

struct { uint8 aByte; uint8 aByteArray[ 64 ] __attribute__ ((aligned (4))); } foo;

(untested)

-- Arne