unaligned.h File Reference

#include <assert.h>
#include <linux/types.h>

Go to the source code of this file.

Macros
#define	__LITTLE_ENDIAN   1
#define	_IS_LITTLE_ENDIAN   1
#define	__get_unaligned_le(ptr)
#define	__get_unaligned_be(ptr)
#define	__put_unaligned_le(val, ptr)
#define	__put_unaligned_be(val, ptr)
#define	get_unaligned   __get_unaligned_le
#define	put_unaligned   __put_unaligned_le

Functions
void	__bad_unaligned_access_size (void)

Macro Definition Documentation

__get_unaligned_be

#define __get_unaligned_be

(

ptr

)

Value:

    ((typeof(*(ptr)))({                            \
    __builtin_choose_expr(sizeof(*(ptr)) == 1, *(ptr),                         \
    __builtin_choose_expr(sizeof(*(ptr)) == 2, get_unaligned_be16((ptr)),      \
    __builtin_choose_expr(sizeof(*(ptr)) == 4, get_unaligned_be32((ptr)),      \
    __builtin_choose_expr(sizeof(*(ptr)) == 8, get_unaligned_be64((ptr)),      \
    __bad_unaligned_access_size()))));                                         \
    }))

__get_unaligned_le

#define __get_unaligned_le

(

ptr

)

Value:

    ((typeof(*(ptr)))({                            \
    __builtin_choose_expr(sizeof(*(ptr)) == 1, *(ptr),                         \
    __builtin_choose_expr(sizeof(*(ptr)) == 2, get_unaligned_le16((ptr)),      \
    __builtin_choose_expr(sizeof(*(ptr)) == 4, get_unaligned_le32((ptr)),      \
    __builtin_choose_expr(sizeof(*(ptr)) == 8, get_unaligned_le64((ptr)),      \
    __bad_unaligned_access_size()))));                                         \
    }))

__LITTLE_ENDIAN

#define __LITTLE_ENDIAN   1

__put_unaligned_be

#define __put_unaligned_be	(		val,
			ptr )

Value:

  ({                                                                           \
    void *__gu_p = (ptr);                                                      \
    switch (sizeof(*(ptr))) {                                                  \
    case 1:                                                                    \
      *(uint8_t *)__gu_p = (uint8_t)(val);                                     \
      break;                                                                   \
    case 2:                                                                    \
      put_unaligned_be16((uint16_t)(val), __gu_p);                             \
      break;                                                                   \
    case 4:                                                                    \
      put_unaligned_be32((uint32_t)(val), __gu_p);                             \
      break;                                                                   \
    case 8:                                                                    \
      put_unaligned_be64((uint64_t)(val), __gu_p);                             \
      break;                                                                   \
    default:                                                                   \
      __bad_unaligned_access_size();                                           \
      break;                                                                   \
    }                                                                          \
    (void)0;                                                                   \
  })

__put_unaligned_le

#define __put_unaligned_le	(		val,
			ptr )

Value:

  ({                                                                           \
    void *__gu_p = (ptr);                                                      \
    switch (sizeof(*(ptr))) {                                                  \
    case 1:                                                                    \
      *(uint8_t *)__gu_p = (uint8_t)(val);                                     \
      break;                                                                   \
    case 2:                                                                    \
      put_unaligned_le16((uint16_t)(val), __gu_p);                             \
      break;                                                                   \
    case 4:                                                                    \
      put_unaligned_le32((uint32_t)(val), __gu_p);                             \
      break;                                                                   \
    case 8:                                                                    \
      put_unaligned_le64((uint64_t)(val), __gu_p);                             \
      break;                                                                   \
    default:                                                                   \
      __bad_unaligned_access_size();                                           \
      break;                                                                   \
    }                                                                          \
    (void)0;                                                                   \
  })

_IS_LITTLE_ENDIAN

#define _IS_LITTLE_ENDIAN   1

get_unaligned

#define get_unaligned   __get_unaligned_le

put_unaligned

#define put_unaligned   __put_unaligned_le

Function Documentation

__bad_unaligned_access_size()

void __bad_unaligned_access_size ( void )

extern