Compile flag for the endian neutral conversion on x86_x64 systems

Question

I am struggling to work on the endianess issue porting the driver and application codes from Sparc to x64 system. The device driver just copies the data in and out the structure from the kernel space to user space or from the user space to kernel space calling ddi_copyin and ddi_copyout in most time. The application ported from Sparc has to be handle the endianess issue.
For instance, the driver returns the data in the structure
typedef struct {
ushort robot_address; /* medium transport element address */
ushort robot_count; /* number medium transport elements */
ushort cell_address; /* medium storage element address */
ushort cell_count; /* number medium storage elements */
ushort port_address; /* import-export element address */
ushort port_count; /* number import-export elements */
ushort drive_address; /* data transfer element address */
ushort drive_count; /* number data transfer elements */
} element_info_t;
Byte _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 A B C D E F
00 01 00 01 10 00 00 17 00 10 00 01 01 00 00 02
First Robot Address ........... 256
Number of Robots .............. 256
First Cell Address ............ 16
Number of Storage Cells ....... 5888
First Import/Export Address ... 4096
Number of Import/Exports ...... 256
First Drive Address ........... 1
Number of Drives .............. 512
The correct value for First Robot Address should be 1 in Byte[0]->Byte[1], but the value is read to 256 in Byte[1]->Byte[0] since of the little endian. To get the correct value, I have to create a micro to convert the data, but it will take a lot of time to add the micro in the codes with 20k lines.
Is any compile flag applied to convert the little endian to big endian to save my life for the porting?
I am using Sun Studio 11 with Sun C 5.8 Patch 121016-02 2006/03/31.
Thanks for your help!

Answer 1

There is no compiler option to control endianness of programs. I don't offhand see how such an option could work, because some data will always be in the machine's native endianness.
But there is a standard Unix toolset "xdr" that allows you to send data across an interface between different architectures, while preserving the data values. Each system knows its native data format. The sender marshalls the data stream into the interface format, and the receiver unmarshalls the stream into its own format.
("Every problem in computer science can be solved by adding a level of indirection.")
Run "man xdr" as a place to start.