quick question

[Perry Smith]

I am 99% sure that if you did this test on an old 68000 type platform  
before 68020(?), it would not work.  Somewhere in the 68000  
genealogy, they added unaligned access.

I believe if you tried this on the old IBM RT it would not work.

I was recently consulted on a problem the client could not solve.  It  
turned out that it was a modern day controller chip (single chip  
computer type thing) that was still based on the 68010 engine.  The  
problem was the code was getting an "odd address exception" because  
it was accessing an unaligned word.

BUT... this is 2006... most machines today have the ability to access  
unaligned data -- but it does cost you in performance.  Also, the  
atomic operations (fetch_and_set, fetch_and_add, etc) I know of no  
platform can do atomic operations on unaligned data.

So, it just depends upon where this is going to be used.  It also  
depends upon why you are doing this in the first place.

On Feb 16, 2006, at 8:57 AM, Jim Stapleton wrote:

> I remember reading that there are systems where they don't like basic
> variables to be put on offsets that are not an integer multiple of the
> variable size, up to variables the size of a system word.
>
> example, if this applied to the 32 bit x86 architechture where a word
> is defined as 4 bytes (I'm talking about the actual arch here, and not
> the bastardized useage form 16bit ASM):
> char [1 byte]: can be anywhere
> short [2 bytes]: any 2N address, where N is an integer, and N > 0.
> int/long [4 bytes]: any 4N address, where N is an integer, and N > 0
> long long [8 bytes]: any 4N address, where N is an integer, and N > 0
> (8 bytes > 1 word)
>
>
> Now, this set of code works on the x86 platform, but I'm worried it
> may not work on other platforms, am I correct in this worry?
>
> #include <stdio.h>
>
> =======================================================
> int main()
> {
>   char test[] =  {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
> 0x08, 0x09, 0x0a};
>   char *tptr = test;
>   int *ptr;
>
>   ptr = (int*)tptr;
>   printf("tptr[0]: %x\n", *ptr);
>
>   tptr++;
>   ptr = (int*)tptr;
>   printf("tptr[1]: %x\n", *ptr);
>
>   tptr++;
>   ptr = (int*)tptr;
>   printf("tptr[2]: %x\n", *ptr);
>
>   tptr++;
>   ptr = (int*)tptr;
>   printf("tptr[3]: %x\n", *ptr);
>
>   return 0;
> }
> =======================================================
>
> output (note: all my machines are 32 bit x86, so this output is
> correct for them, on reasonable endian machines, the bytes in the
> output would be reversed):
> tptr[0]: 3020100
> tptr[1]: 4030201
> tptr[2]: 5040302
> tptr[3]: 6050403
>
>
>
> Thanks
> -Jim
>