osiWireFormat.h

/*************************************************************************\
* Copyright (c) 2007 UChicago Argonne LLC, as Operator of Argonne
* National Laboratory.
* Copyright (c) 2002 The Regents of the University of California, as
* Operator of Los Alamos National Laboratory.
* SPDX-License-Identifier: EPICS
* EPICS BASE is distributed subject to a Software License Agreement found
* in file LICENSE that is included with this distribution.
\*************************************************************************/

/*
 * Author Jeffrey O. Hill
 * [email protected]
 */

#ifndef osiWireFormat
#define osiWireFormat

#include "epicsTypes.h"

//
// With future CA protocols user defined payload composition will be
// supported and we will need to move away from a naturally aligned
// protocol (because pad byte overhead will probably be excessive when
// maintaining 8 byte natural alignment if the user isn't thinking about
// placing like sized elements together).
//
// Nevertheless, the R3.14 protocol continues to be naturally aligned,
// and all of the fields within the DBR_XXXX types are naturally aligned.
// Therefore we support here two wire transfer interfaces (naturally
// aligned and otherwise) because there are important optimizations
// specific to each of them.
//
// At some point in the future the naturally aligned interfaces might
// be eliminated (or unbundled from base) should they be no-longer needed.
//

template < class T >
void WireGet ( const epicsUInt8 * pWireSrc, T & );

template < class T >
void WireSet ( const T &, epicsUInt8 * pWireDst );

template < class T >
void AlignedWireGet ( const T &, T & );

template < class T >
void AlignedWireSet ( const T &, T & );

template < class T >
class AlignedWireRef {
public:
 AlignedWireRef ( T & ref );
 operator T () const;
 AlignedWireRef < T > & operator = ( const T & );
private:
 T & _ref;
 AlignedWireRef ( const AlignedWireRef & );
 AlignedWireRef & operator = ( const AlignedWireRef & );
};

template < class T >
class AlignedWireRef < const T > {
public:
 AlignedWireRef ( const T & ref );
 operator T () const;
private:
 const T & _ref;
 AlignedWireRef ( const AlignedWireRef & );
 AlignedWireRef & operator = ( const AlignedWireRef & );
};

template < class T >
inline AlignedWireRef < T > :: AlignedWireRef ( T & ref ) :
 _ref ( ref )
{
}

template < class T >
inline AlignedWireRef < T > :: operator T () const
{
 T tmp;
 AlignedWireGet ( _ref, tmp );
 return tmp;
}

template < class T >
inline AlignedWireRef < T > & AlignedWireRef < T > :: operator = ( const T & src )
{
 AlignedWireSet ( src, _ref );
 return *this;
}

template < class T >
inline AlignedWireRef < const T > :: AlignedWireRef ( const T & ref ) :
 _ref ( ref )
{
}

template < class T >
inline AlignedWireRef < const T > :: operator T () const
{
 T tmp;
 AlignedWireGet ( _ref, tmp );
 return tmp;
}

// may be useful when creating support for little endian
inline epicsUInt16 byteSwap ( const epicsUInt16 & src )
{
 return static_cast < epicsUInt16 >
 ( ( src << 8u ) | ( src >> 8u ) );
}

// may be useful when creating support for little endian
inline epicsUInt32 byteSwap ( const epicsUInt32 & src )
{
 epicsUInt32 tmp0 = byteSwap (
 static_cast < epicsUInt16 > ( src >> 16u ) );
 epicsUInt32 tmp1 = byteSwap (
 static_cast < epicsUInt16 > ( src ) );
 return static_cast < epicsUInt32 >
 ( ( tmp1 << 16u ) | tmp0 );
}

template < class T > union WireAlias;

template <>
union WireAlias < epicsInt8 > {
 epicsUInt8 _u;
 epicsInt8 _o;
};

template <>
union WireAlias < epicsInt16 > {
 epicsUInt16 _u;
 epicsInt16 _o;
};

template <>
union WireAlias < epicsInt32 > {
 epicsUInt32 _u;
 epicsInt32 _o;
};

template <>
union WireAlias < epicsFloat32 > {
 epicsUInt32 _u;
 epicsFloat32 _o;
};

//
// Missaligned unsigned wire format get/set can be implemented generically
// w/o performance penalty. Attempts to improve this on architectures that
// don't have alignment requirements will probably get into trouble with
// over-aggressive optimization under strict aliasing rules.
//

template < class T >
inline void WireGet ( const epicsUInt8 * pWireSrc, T & dst )
{
 // copy through union here
 // a) prevents over-aggressive optimization under strict aliasing rules
 // b) doesnt preclude extra copy operation being optimized away
 WireAlias < T > tmp;
 WireGet ( pWireSrc, tmp._u );
 dst = tmp._o;
}

template <>
inline void WireGet < epicsUInt8 > (
 const epicsUInt8 * pWireSrc, epicsUInt8 & dst )
{
 dst = pWireSrc[0];
}

template <>
inline void WireGet < epicsUInt16 > (
 const epicsUInt8 * pWireSrc, epicsUInt16 & dst )
{
 dst = static_cast < epicsUInt16 > (
 ( pWireSrc[0] << 8u ) | pWireSrc[1] );
}

template <>
inline void WireGet < epicsUInt32 > (
 const epicsUInt8 * pWireSrc, epicsUInt32 & dst )
{
 dst = static_cast < epicsUInt32 > (
 ( pWireSrc[0] << 24u ) |
 ( pWireSrc[1] << 16u ) |
 ( pWireSrc[2] << 8u ) |
 pWireSrc[3] );
}

template < class T >
inline void WireSet ( const T & src, epicsUInt8 * pWireDst )
{
 // copy through union here
 // a) prevents over-aggressive optimization under strict aliasing rules
 // b) doesnt preclude extra copy operation being optimized away
 WireAlias < T > tmp;
 tmp._o = src;
 WireSet ( tmp._u, pWireDst );
}

template <>
inline void WireSet < epicsUInt8 > (
 const epicsUInt8 & src, epicsUInt8 * pWireDst )
{
 pWireDst[0] = src;
}

template <>
inline void WireSet < epicsUInt16 > (
 const epicsUInt16 & src, epicsUInt8 * pWireDst )
{
 pWireDst[0] = static_cast < epicsUInt8 > ( src >> 8u );
 pWireDst[1] = static_cast < epicsUInt8 > ( src );
}

template <>
inline void WireSet < epicsUInt32 > (
 const epicsUInt32 & src, epicsUInt8 * pWireDst )
{
 pWireDst[0] = static_cast < epicsUInt8 > ( src >> 24u );
 pWireDst[1] = static_cast < epicsUInt8 > ( src >> 16u );
 pWireDst[2] = static_cast < epicsUInt8 > ( src >> 8u );
 pWireDst[3] = static_cast < epicsUInt8 > ( src );
}

template < class T >
inline void AlignedWireGet ( const T & src, T & dst )
{
 // copy through union here
 // a) prevents over-aggressive optimization under strict aliasing rules
 // b) doesnt preclude extra copy operation being optimized away
 WireAlias < T > srcu, dstu;
 srcu._o = src;
 AlignedWireGet ( srcu._u, dstu._u );
 dst = dstu._o;
}

template < class T >
inline void AlignedWireSet ( const T & src, T & dst )
{
 // copy through union here
 // a) prevents over-aggressive optimization under strict aliasing rules
 // b) doesnt preclude extra copy operation being optimized away
 WireAlias < T > srcu, dstu;
 srcu._o = src;
 AlignedWireSet ( srcu._u, dstu._u );
 dst = dstu._o;
}

#include "osdWireFormat.h"

#endif // osiWireFormat