[boost] Access to unaligned (packed) structs - ONE FINAL TRY - Formatting problems

From: Sid Sacek (ssacek_at_[hidden])
Date: 2007-10-11 15:38:48

#include <stdio.h>

#define CPU_SPARC		( defined( __sparc ) || defined( sparc ) )
#include "safe_access.h"

#pragma pack( 1 )
struct foo
{
            unsigned char    a;		// doesn't need safe access
        SA( unsigned int  )  b;		// unaligned int needs safe access
};
#pragma pack()

int main( int, char ** )
{
        foo foo = {  0xAA, 0xBBBBBBBB  };

        unsigned char a = foo.a;
        unsigned int  b = foo.b;

        printf( " &a = %p    a = %x \n", &foo.a,  a );
        printf( " &b = %p    b = %x \n", &foo.b,  b );

        foo.a = 0x12;
        foo.b = 0x34567890;

        printf( " a = %x \n", int( foo.a ) );
        printf( " b = %x \n", int( foo.b ) );
}

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//---------------------------------------------------------------------------------------
//	                                Safe Access
//
//	These routines are used to access memory addresses that would cause bus-errors on the
//	SPARC platform if accessed in the normal C++ way, due to misaligned memory addresses.
//---------------------------------------------------------------------------------------
#ifndef __SAFE_ACCESS_H__
#define __SAFE_ACCESS_H__
#pragma once

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//---------------------------------------------------------------------------------------
//	                            Safe Variable Copy
//
//	These routines behave like memcpy function calls, but are specialized for data type
//	sizes 2, 4, and 8 bytes. It is designed to execute in the fewest number of assembly
//	instructions without calling memcpy. Under the SUN platform using SPARC processors,
//	crashes occur with bus-alignment errors when data is located at random addresses.
//---------------------------------------------------------------------------------------
template< int Sizeof_Variable > void safe_variable_copy( void *, const void * );

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//---------------------------------------------------------------------------------------
//	                      Specialization for sizeof( short )
//
//	safe_variable_copy< 2 >( &left, &right )
//---------------------------------------------------------------------------------------
template<>
inline void safe_variable_copy< 2 >( void * left, const void * right )
{
        static_cast< char * >( left )[ 0 ] = static_cast< const char * >( right )[ 0 ];
        static_cast< char * >( left )[ 1 ] = static_cast< const char * >( right )[ 1 ];
}

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//---------------------------------------------------------------------------------------
//	                     Specialization for sizeof( int )
//
//	safe_variable_copy< 4 >( &left, &right )
//---------------------------------------------------------------------------------------
template<>
inline void safe_variable_copy< 4 >( void * left, const void * right )
{
        static_cast< char * >( left )[ 0 ] = static_cast< const char * >( right )[ 0 ];
        static_cast< char * >( left )[ 1 ] = static_cast< const char * >( right )[ 1 ];
        static_cast< char * >( left )[ 2 ] = static_cast< const char * >( right )[ 2 ];
        static_cast< char * >( left )[ 3 ] = static_cast< const char * >( right )[ 3 ];
}

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//---------------------------------------------------------------------------------------
//	                 Specialization for sizeof( long long )
//
//	safe_variable_copy< 8 >( &left, &right )
//---------------------------------------------------------------------------------------
template<>
inline void safe_variable_copy< 8 >( void * left, const void * right )
{
        static_cast< char * >( left )[ 0 ] = static_cast< const char * >( right )[ 0 ];
        static_cast< char * >( left )[ 1 ] = static_cast< const char * >( right )[ 1 ];
        static_cast< char * >( left )[ 2 ] = static_cast< const char * >( right )[ 2 ];
        static_cast< char * >( left )[ 3 ] = static_cast< const char * >( right )[ 3 ];
        static_cast< char * >( left )[ 4 ] = static_cast< const char * >( right )[ 4 ];
        static_cast< char * >( left )[ 5 ] = static_cast< const char * >( right )[ 5 ];
        static_cast< char * >( left )[ 6 ] = static_cast< const char * >( right )[ 6 ];
        static_cast< char * >( left )[ 7 ] = static_cast< const char * >( right )[ 7 ];
}

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//---------------------------------------------------------------------------------------
//	                               Safe Access
//
//	This templated function is used to prevent a bus errors under the SUN SPARC systems.
//	We wrap the misaligned variables with a function call to this routine.
//---------------------------------------------------------------------------------------
template< typename Ty >
inline Ty safe_access( const Ty & value )
{
        Ty result;						// access memory using a memory-aligned variable
        safe_variable_copy< sizeof( Ty ) >( &result, &value );
        return result;					// pass back the value from misaligned variable
}

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//---------------------------------------------------------------------------------------
//	                        Safe Access Data Wrapper
//
//	This wrapper class is used to wrap data defined in structures that are possibly
//	misaligned for the computer's bus architecture. It is typically meant to be used
//	inside data structures that are packed using the #pragma pack(n).
//
//	Example of usage:
//
#if 0
                #pragma pack(1)
                struct Packed_Structure
                {
                        u8        status;		// this is aligned at offset 0
                        SA( u32 ) value;		// this is aligned at offset 1 ( can cause a bus error )
                };
                #pragma pack()

                void foo( Packed_Structure * pk )
                {
                        u8  var1 = pk->status;
                        u32 var2 = pk->value;	// this can no longer cause a bus error
                }
#endif
//
//	The data type 'SA( u32 )' in the above structure uses the 'safe_access' method to
//	ensure that bus errors don't occur when the data is being accessed on the fragile
//	platform. Since the network structures are typically packed, and possibly aligned
//	on addresses that can cause bus errors, the structure's data elements should use
//	versions of data elements that are 'access safe'.
//---------------------------------------------------------------------------------------
template< typename Ty >
struct safe_access_wrapper
{
        Ty m_data;				// contains the data that is possibly misaligned
        operator Ty() const {  return safe_access( m_data );  }
        const Ty & operator = ( const Ty & value ) {  safe_variable_copy< sizeof( Ty ) >( &m_data, &value ); return m_data;  }
};

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//---------------------------------------------------------------------------------------
//	                        SAFE() Macro ( Safe Access )
//	                        SA()   Macro ( Safe Access Type Wrapper )
//
//	The SA() macro is used to wrap structure elements inside packed structures that may
//	cause bus errors when accessed, like on the SPARC processors.
//	Example of usage:
//
//  #pragma pack(1)
//	struct Packed_Structure
//	{
//		u8        byte_aligned;		// accessing this never causes a bus error
//		SA( u32 ) mis_aligned;		// accessing this can no longer cause a bus error
//	};
//
//	The SAFE() macro is used to wrap access to basic data types that cause bus errors.
//	Example of usage:
//
//	void foo( Packed_Structure * pk )
//	{
//		u32 var1 =       pk->variable;    // this may cause a bus error on the SPARC chip
//		u32 var2 = SAFE( pk->variable );  // this can no longer cause a bus error
//	}
//---------------------------------------------------------------------------------------
#if CPU_SPARC
        #define   SA( type )			safe_access_wrapper< type >
        #define SAFE( argument )		safe_access( argument )
#else
        #define   SA( type )			type
        #define SAFE( argument )		( argument )
#endif

#endif //                    #ifndef __SAFE_ACCESS_H__
//
//---------------------------------------------------------------------------------------
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++