Casting in 64 bit Solaris 28 Forte 6

Question

I have the following piece of code
char crap[10000];
if (rand() % 2 == 0) // really try fooling daemon
crap[0] = 0;
crap[1] = 0;
crap[2] = 0;
crap[3] = size;
crap[4] = 0;
crap[5] = 0;
crap[6] = 0;
crap[7] = rand() % 4;
i = 8;
cout << " set size " << size << " " << crap[3] << endl;
srand(time(0));
for (; i < 10000; i++)
crap[i] = rand() % 256;
//cores here
cout << " sending the daemon len " << *(unsigned long*) crap << " type " << *(long*)(crap + 4) << endl;
The second cout cores on the casting part of *(unsigned long*) crap .
Error for the core is -->terminated by signal BUS (invalid address alignment)
Now this doesnt happen in 32 bit, so why does it happen in 64 bit?? Any ideas or places where i can read up on it and find a fix?
Thanks
T

Answer 1

According to the C and C++ standards, if you cast a pointer to a different type and dereference, the results are undefined. If your code ever works, it is only by accident.
An array of char can be allocated at any location. On SPARC in particular, larger types have stricter alignment requirements. You are depending on an element of a char array being aligned properly for a type that has stricter alignment requirements, a dependecy that is certain to fail on one or more platforms.
In this particular case, the char array is not local to a function, and so is likely to be aligned on a 4-byte boundary, so the address crap+4 is also likely to be 4-byte aligned.
In 32-bit mode, type long is 32 bits, and must be aligned on a 4-byte boundary. If crap is on a 4-byte boundary, the code *(long*)(crap+4) will work.
In 64-bit mode, type long is 64 bits, and must be aligned on an 8-byte boundary. The address crap+4 has at best a 50% chance of being 8-byte aligned, and if it is not, you get a runtime failure trying to execute *(long*)(crap+4).
The best solution is not to use a char array to store integer data; use an array of the appropriate type. If you have mixed data types, use a struct, an array of structs, or an array of unions. The compiler will ensure that everything is properly aligned, no matter what compiler or platform you use.
If you must store integer data in a char array, you can use
#pragma align
to force the array to an appropriate alignment. If you need to compile in 64-bit mode, force the array to 8-byte alignment, and use an offset that is a multiple of 8 for the location of the long.
If you can't do any of these things, you have a few other options.
Compilier option -misalign tells the compiler to assume that data might not be aligned correctly, and to load one byte at a time if it can't be sure about alignment. This option kills performance, sometimes to an unacceptable degree. If you must use it, confine all the misaligned access to one module that does little besides access the data, and compile only that module with -misalign. This module must return data by value, not by pointer or reference, because a pointer or reference might point to misaligned data.
You are using an outdated and unsupported compiler. If you upgrade to a recent version, you can also use the -xmemalign option, which allows the compiler to be less pessimistic about alignment.
I recommend upgrading to Sun Studio 11, which is free. You can get it here:
http://developers.sun.com/sunstudio/