byteorder: only use linux/swab.h
The first step to make swab.h a regular header that will include an asm/swab.h with arch overrides. Avoid the gratuitous differences introduced in the new linux/swab.h by naming the ___constant_swabXX bits and __fswabXX bits exactly as found in the old implementation in byteorder/swab[b].h Use this new swab.h in byteorder/[big|little]_endian.h and remove the two old swab headers. Although the inclusion of asm/byteorder.h looks strange in linux/swab.h, this will allow each arch to move the actual arch overrides for the swab bits in an asm file and then the includes can be cleaned up without requiring a flag day for all arches at once. Keep providing __fswabXX in case some userspace was using them directly, but the revised __swabXX should be used instead in any new code and will always do constant folding not dependent on the optimization level, which means the __constant versions can be phased out in-kernel. Arches that use the old-style arch macros will lose their optimized versions until they move to the new style, but at least they will still compile. Many arches have already moved and the patches to move the remaining arches are trivial. Signed-off-by: Harvey Harrison <harvey.harrison@gmail.com> Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
This commit is contained in:
Harvey Harrison
Linus Torvalds
Родитель
c89a9f5a42
Коммит
991c0e6d1a
|
|
@ -1,4 +1,2 @@
|
|||
unifdef-y += big_endian.h
|
||||
unifdef-y += little_endian.h
|
||||
unifdef-y += swab.h
|
||||
unifdef-y += swabb.h
|
||||
|
|
|
|||
|
|
@ -9,8 +9,7 @@
|
|||
#endif
|
||||
|
||||
#include <linux/types.h>
|
||||
#include <linux/byteorder/swab.h>
|
||||
#include <linux/byteorder/swabb.h>
|
||||
#include <linux/swab.h>
|
||||
|
||||
#define __constant_htonl(x) ((__force __be32)(__u32)(x))
|
||||
#define __constant_ntohl(x) ((__force __u32)(__be32)(x))
|
||||
|
|
|
|||
|
|
@ -9,8 +9,7 @@
|
|||
#endif
|
||||
|
||||
#include <linux/types.h>
|
||||
#include <linux/byteorder/swab.h>
|
||||
#include <linux/byteorder/swabb.h>
|
||||
#include <linux/swab.h>
|
||||
|
||||
#define __constant_htonl(x) ((__force __be32)___constant_swab32((x)))
|
||||
#define __constant_ntohl(x) ___constant_swab32((__force __be32)(x))
|
||||
|
|
|
|||
|
|
@ -1,222 +0,0 @@
|
|||
#ifndef _LINUX_BYTEORDER_SWAB_H
|
||||
#define _LINUX_BYTEORDER_SWAB_H
|
||||
|
||||
/*
|
||||
* linux/byteorder/swab.h
|
||||
* Byte-swapping, independently from CPU endianness
|
||||
* swabXX[ps]?(foo)
|
||||
*
|
||||
* Francois-Rene Rideau <fare@tunes.org> 19971205
|
||||
* separated swab functions from cpu_to_XX,
|
||||
* to clean up support for bizarre-endian architectures.
|
||||
*
|
||||
* Trent Piepho <xyzzy@speakeasy.org> 2007114
|
||||
* make constant-folding work, provide C versions that
|
||||
* gcc can optimize better, explain different versions
|
||||
*
|
||||
* See asm-i386/byteorder.h and suches for examples of how to provide
|
||||
* architecture-dependent optimized versions
|
||||
*
|
||||
*/
|
||||
|
||||
#include <linux/compiler.h>
|
||||
|
||||
/* Functions/macros defined, there are a lot:
|
||||
*
|
||||
* ___swabXX
|
||||
* Generic C versions of the swab functions.
|
||||
*
|
||||
* ___constant_swabXX
|
||||
* C versions that gcc can fold into a compile-time constant when
|
||||
* the argument is a compile-time constant.
|
||||
*
|
||||
* __arch__swabXX[sp]?
|
||||
* Architecture optimized versions of all the swab functions
|
||||
* (including the s and p versions). These can be defined in
|
||||
* asm-arch/byteorder.h. Any which are not, are defined here.
|
||||
* __arch__swabXXs() is defined in terms of __arch__swabXXp(), which
|
||||
* is defined in terms of __arch__swabXX(), which is in turn defined
|
||||
* in terms of ___swabXX(x).
|
||||
* These must be macros. They may be unsafe for arguments with
|
||||
* side-effects.
|
||||
*
|
||||
* __fswabXX
|
||||
* Inline function versions of the __arch__ macros. These _are_ safe
|
||||
* if the arguments have side-effects. Note there are no s and p
|
||||
* versions of these.
|
||||
*
|
||||
* __swabXX[sb]
|
||||
* There are the ones you should actually use. The __swabXX versions
|
||||
* will be a constant given a constant argument and use the arch
|
||||
* specific code (if any) for non-constant arguments. The s and p
|
||||
* versions always use the arch specific code (constant folding
|
||||
* doesn't apply). They are safe to use with arguments with
|
||||
* side-effects.
|
||||
*
|
||||
* swabXX[sb]
|
||||
* Nicknames for __swabXX[sb] to use in the kernel.
|
||||
*/
|
||||
|
||||
/* casts are necessary for constants, because we never know how for sure
|
||||
* how U/UL/ULL map to __u16, __u32, __u64. At least not in a portable way.
|
||||
*/
|
||||
|
||||
static __inline__ __attribute_const__ __u16 ___swab16(__u16 x)
|
||||
{
|
||||
return x<<8 | x>>8;
|
||||
}
|
||||
static __inline__ __attribute_const__ __u32 ___swab32(__u32 x)
|
||||
{
|
||||
return x<<24 | x>>24 |
|
||||
(x & (__u32)0x0000ff00UL)<<8 |
|
||||
(x & (__u32)0x00ff0000UL)>>8;
|
||||
}
|
||||
static __inline__ __attribute_const__ __u64 ___swab64(__u64 x)
|
||||
{
|
||||
return x<<56 | x>>56 |
|
||||
(x & (__u64)0x000000000000ff00ULL)<<40 |
|
||||
(x & (__u64)0x0000000000ff0000ULL)<<24 |
|
||||
(x & (__u64)0x00000000ff000000ULL)<< 8 |
|
||||
(x & (__u64)0x000000ff00000000ULL)>> 8 |
|
||||
(x & (__u64)0x0000ff0000000000ULL)>>24 |
|
||||
(x & (__u64)0x00ff000000000000ULL)>>40;
|
||||
}
|
||||
|
||||
#define ___constant_swab16(x) \
|
||||
((__u16)( \
|
||||
(((__u16)(x) & (__u16)0x00ffU) << 8) | \
|
||||
(((__u16)(x) & (__u16)0xff00U) >> 8) ))
|
||||
#define ___constant_swab32(x) \
|
||||
((__u32)( \
|
||||
(((__u32)(x) & (__u32)0x000000ffUL) << 24) | \
|
||||
(((__u32)(x) & (__u32)0x0000ff00UL) << 8) | \
|
||||
(((__u32)(x) & (__u32)0x00ff0000UL) >> 8) | \
|
||||
(((__u32)(x) & (__u32)0xff000000UL) >> 24) ))
|
||||
#define ___constant_swab64(x) \
|
||||
((__u64)( \
|
||||
(__u64)(((__u64)(x) & (__u64)0x00000000000000ffULL) << 56) | \
|
||||
(__u64)(((__u64)(x) & (__u64)0x000000000000ff00ULL) << 40) | \
|
||||
(__u64)(((__u64)(x) & (__u64)0x0000000000ff0000ULL) << 24) | \
|
||||
(__u64)(((__u64)(x) & (__u64)0x00000000ff000000ULL) << 8) | \
|
||||
(__u64)(((__u64)(x) & (__u64)0x000000ff00000000ULL) >> 8) | \
|
||||
(__u64)(((__u64)(x) & (__u64)0x0000ff0000000000ULL) >> 24) | \
|
||||
(__u64)(((__u64)(x) & (__u64)0x00ff000000000000ULL) >> 40) | \
|
||||
(__u64)(((__u64)(x) & (__u64)0xff00000000000000ULL) >> 56) ))
|
||||
|
||||
/*
|
||||
* provide defaults when no architecture-specific optimization is detected
|
||||
*/
|
||||
#ifndef __arch__swab16
|
||||
# define __arch__swab16(x) ___swab16(x)
|
||||
#endif
|
||||
#ifndef __arch__swab32
|
||||
# define __arch__swab32(x) ___swab32(x)
|
||||
#endif
|
||||
#ifndef __arch__swab64
|
||||
# define __arch__swab64(x) ___swab64(x)
|
||||
#endif
|
||||
|
||||
#ifndef __arch__swab16p
|
||||
# define __arch__swab16p(x) __arch__swab16(*(x))
|
||||
#endif
|
||||
#ifndef __arch__swab32p
|
||||
# define __arch__swab32p(x) __arch__swab32(*(x))
|
||||
#endif
|
||||
#ifndef __arch__swab64p
|
||||
# define __arch__swab64p(x) __arch__swab64(*(x))
|
||||
#endif
|
||||
|
||||
#ifndef __arch__swab16s
|
||||
# define __arch__swab16s(x) ((void)(*(x) = __arch__swab16p(x)))
|
||||
#endif
|
||||
#ifndef __arch__swab32s
|
||||
# define __arch__swab32s(x) ((void)(*(x) = __arch__swab32p(x)))
|
||||
#endif
|
||||
#ifndef __arch__swab64s
|
||||
# define __arch__swab64s(x) ((void)(*(x) = __arch__swab64p(x)))
|
||||
#endif
|
||||
|
||||
|
||||
/*
|
||||
* Allow constant folding
|
||||
*/
|
||||
#if defined(__GNUC__) && defined(__OPTIMIZE__)
|
||||
# define __swab16(x) \
|
||||
(__builtin_constant_p((__u16)(x)) ? \
|
||||
___constant_swab16((x)) : \
|
||||
__fswab16((x)))
|
||||
# define __swab32(x) \
|
||||
(__builtin_constant_p((__u32)(x)) ? \
|
||||
___constant_swab32((x)) : \
|
||||
__fswab32((x)))
|
||||
# define __swab64(x) \
|
||||
(__builtin_constant_p((__u64)(x)) ? \
|
||||
___constant_swab64((x)) : \
|
||||
__fswab64((x)))
|
||||
#else
|
||||
# define __swab16(x) __fswab16(x)
|
||||
# define __swab32(x) __fswab32(x)
|
||||
# define __swab64(x) __fswab64(x)
|
||||
#endif /* OPTIMIZE */
|
||||
|
||||
|
||||
static __inline__ __attribute_const__ __u16 __fswab16(__u16 x)
|
||||
{
|
||||
return __arch__swab16(x);
|
||||
}
|
||||
static __inline__ __u16 __swab16p(const __u16 *x)
|
||||
{
|
||||
return __arch__swab16p(x);
|
||||
}
|
||||
static __inline__ void __swab16s(__u16 *addr)
|
||||
{
|
||||
__arch__swab16s(addr);
|
||||
}
|
||||
|
||||
static __inline__ __attribute_const__ __u32 __fswab32(__u32 x)
|
||||
{
|
||||
return __arch__swab32(x);
|
||||
}
|
||||
static __inline__ __u32 __swab32p(const __u32 *x)
|
||||
{
|
||||
return __arch__swab32p(x);
|
||||
}
|
||||
static __inline__ void __swab32s(__u32 *addr)
|
||||
{
|
||||
__arch__swab32s(addr);
|
||||
}
|
||||
|
||||
#ifdef __BYTEORDER_HAS_U64__
|
||||
static __inline__ __attribute_const__ __u64 __fswab64(__u64 x)
|
||||
{
|
||||
# ifdef __SWAB_64_THRU_32__
|
||||
__u32 h = x >> 32;
|
||||
__u32 l = x & ((1ULL<<32)-1);
|
||||
return (((__u64)__swab32(l)) << 32) | ((__u64)(__swab32(h)));
|
||||
# else
|
||||
return __arch__swab64(x);
|
||||
# endif
|
||||
}
|
||||
static __inline__ __u64 __swab64p(const __u64 *x)
|
||||
{
|
||||
return __arch__swab64p(x);
|
||||
}
|
||||
static __inline__ void __swab64s(__u64 *addr)
|
||||
{
|
||||
__arch__swab64s(addr);
|
||||
}
|
||||
#endif /* __BYTEORDER_HAS_U64__ */
|
||||
|
||||
#if defined(__KERNEL__)
|
||||
#define swab16 __swab16
|
||||
#define swab32 __swab32
|
||||
#define swab64 __swab64
|
||||
#define swab16p __swab16p
|
||||
#define swab32p __swab32p
|
||||
#define swab64p __swab64p
|
||||
#define swab16s __swab16s
|
||||
#define swab32s __swab32s
|
||||
#define swab64s __swab64s
|
||||
#endif
|
||||
|
||||
#endif /* _LINUX_BYTEORDER_SWAB_H */
|
||||
|
|
@ -1,135 +0,0 @@
|
|||
#ifndef _LINUX_BYTEORDER_SWABB_H
|
||||
#define _LINUX_BYTEORDER_SWABB_H
|
||||
|
||||
/*
|
||||
* linux/byteorder/swabb.h
|
||||
* SWAp Bytes Bizarrely
|
||||
* swaHHXX[ps]?(foo)
|
||||
*
|
||||
* Support for obNUXIous pdp-endian and other bizarre architectures.
|
||||
* Will Linux ever run on such ancient beasts? if not, this file
|
||||
* will be but a programming pearl. Still, it's a reminder that we
|
||||
* shouldn't be making too many assumptions when trying to be portable.
|
||||
*
|
||||
*/
|
||||
|
||||
/*
|
||||
* Meaning of the names I chose (vaxlinux people feel free to correct them):
|
||||
* swahw32 swap 16-bit half-words in a 32-bit word
|
||||
* swahb32 swap 8-bit halves of each 16-bit half-word in a 32-bit word
|
||||
*
|
||||
* No 64-bit support yet. I don't know NUXI conventions for long longs.
|
||||
* I guarantee it will be a mess when it's there, though :->
|
||||
* It will be even worse if there are conflicting 64-bit conventions.
|
||||
* Hopefully, no one ever used 64-bit objects on NUXI machines.
|
||||
*
|
||||
*/
|
||||
|
||||
#include <linux/types.h>
|
||||
|
||||
#define ___swahw32(x) \
|
||||
({ \
|
||||
__u32 __x = (x); \
|
||||
((__u32)( \
|
||||
(((__u32)(__x) & (__u32)0x0000ffffUL) << 16) | \
|
||||
(((__u32)(__x) & (__u32)0xffff0000UL) >> 16) )); \
|
||||
})
|
||||
#define ___swahb32(x) \
|
||||
({ \
|
||||
__u32 __x = (x); \
|
||||
((__u32)( \
|
||||
(((__u32)(__x) & (__u32)0x00ff00ffUL) << 8) | \
|
||||
(((__u32)(__x) & (__u32)0xff00ff00UL) >> 8) )); \
|
||||
})
|
||||
|
||||
#define ___constant_swahw32(x) \
|
||||
((__u32)( \
|
||||
(((__u32)(x) & (__u32)0x0000ffffUL) << 16) | \
|
||||
(((__u32)(x) & (__u32)0xffff0000UL) >> 16) ))
|
||||
#define ___constant_swahb32(x) \
|
||||
((__u32)( \
|
||||
(((__u32)(x) & (__u32)0x00ff00ffUL) << 8) | \
|
||||
(((__u32)(x) & (__u32)0xff00ff00UL) >> 8) ))
|
||||
|
||||
/*
|
||||
* provide defaults when no architecture-specific optimization is detected
|
||||
*/
|
||||
#ifndef __arch__swahw32
|
||||
# define __arch__swahw32(x) ___swahw32(x)
|
||||
#endif
|
||||
#ifndef __arch__swahb32
|
||||
# define __arch__swahb32(x) ___swahb32(x)
|
||||
#endif
|
||||
|
||||
#ifndef __arch__swahw32p
|
||||
# define __arch__swahw32p(x) __swahw32(*(x))
|
||||
#endif
|
||||
#ifndef __arch__swahb32p
|
||||
# define __arch__swahb32p(x) __swahb32(*(x))
|
||||
#endif
|
||||
|
||||
#ifndef __arch__swahw32s
|
||||
# define __arch__swahw32s(x) do { *(x) = __swahw32p((x)); } while (0)
|
||||
#endif
|
||||
#ifndef __arch__swahb32s
|
||||
# define __arch__swahb32s(x) do { *(x) = __swahb32p((x)); } while (0)
|
||||
#endif
|
||||
|
||||
|
||||
/*
|
||||
* Allow constant folding
|
||||
*/
|
||||
#define __swahw32(x) \
|
||||
(__builtin_constant_p((__u32)(x)) ? \
|
||||
___swahw32((x)) : \
|
||||
__fswahw32((x)))
|
||||
#define __swahb32(x) \
|
||||
(__builtin_constant_p((__u32)(x)) ? \
|
||||
___swahb32((x)) : \
|
||||
__fswahb32((x)))
|
||||
|
||||
|
||||
static inline __u32 __fswahw32(__u32 x)
|
||||
{
|
||||
return __arch__swahw32(x);
|
||||
}
|
||||
|
||||
static inline __u32 __swahw32p(__u32 *x)
|
||||
{
|
||||
return __arch__swahw32p(x);
|
||||
}
|
||||
|
||||
static inline void __swahw32s(__u32 *addr)
|
||||
{
|
||||
__arch__swahw32s(addr);
|
||||
}
|
||||
|
||||
static inline __u32 __fswahb32(__u32 x)
|
||||
{
|
||||
return __arch__swahb32(x);
|
||||
}
|
||||
|
||||
static inline __u32 __swahb32p(__u32 *x)
|
||||
{
|
||||
return __arch__swahb32p(x);
|
||||
}
|
||||
|
||||
static inline void __swahb32s(__u32 *addr)
|
||||
{
|
||||
__arch__swahb32s(addr);
|
||||
}
|
||||
|
||||
#ifdef __BYTEORDER_HAS_U64__
|
||||
/*
|
||||
* Not supported yet
|
||||
*/
|
||||
#endif /* __BYTEORDER_HAS_U64__ */
|
||||
|
||||
#define swahw32 __swahw32
|
||||
#define swahb32 __swahb32
|
||||
#define swahw32p __swahw32p
|
||||
#define swahb32p __swahb32p
|
||||
#define swahw32s __swahw32s
|
||||
#define swahb32s __swahb32s
|
||||
|
||||
#endif /* _LINUX_BYTEORDER_SWABB_H */
|
||||
|
|
@ -9,17 +9,17 @@
|
|||
* casts are necessary for constants, because we never know how for sure
|
||||
* how U/UL/ULL map to __u16, __u32, __u64. At least not in a portable way.
|
||||
*/
|
||||
#define __const_swab16(x) ((__u16)( \
|
||||
#define ___constant_swab16(x) ((__u16)( \
|
||||
(((__u16)(x) & (__u16)0x00ffU) << 8) | \
|
||||
(((__u16)(x) & (__u16)0xff00U) >> 8)))
|
||||
|
||||
#define __const_swab32(x) ((__u32)( \
|
||||
#define ___constant_swab32(x) ((__u32)( \
|
||||
(((__u32)(x) & (__u32)0x000000ffUL) << 24) | \
|
||||
(((__u32)(x) & (__u32)0x0000ff00UL) << 8) | \
|
||||
(((__u32)(x) & (__u32)0x00ff0000UL) >> 8) | \
|
||||
(((__u32)(x) & (__u32)0xff000000UL) >> 24)))
|
||||
|
||||
#define __const_swab64(x) ((__u64)( \
|
||||
#define ___constant_swab64(x) ((__u64)( \
|
||||
(((__u64)(x) & (__u64)0x00000000000000ffULL) << 56) | \
|
||||
(((__u64)(x) & (__u64)0x000000000000ff00ULL) << 40) | \
|
||||
(((__u64)(x) & (__u64)0x0000000000ff0000ULL) << 24) | \
|
||||
|
|
@ -29,11 +29,11 @@
|
|||
(((__u64)(x) & (__u64)0x00ff000000000000ULL) >> 40) | \
|
||||
(((__u64)(x) & (__u64)0xff00000000000000ULL) >> 56)))
|
||||
|
||||
#define __const_swahw32(x) ((__u32)( \
|
||||
#define ___constant_swahw32(x) ((__u32)( \
|
||||
(((__u32)(x) & (__u32)0x0000ffffUL) << 16) | \
|
||||
(((__u32)(x) & (__u32)0xffff0000UL) >> 16)))
|
||||
|
||||
#define __const_swahb32(x) ((__u32)( \
|
||||
#define ___constant_swahb32(x) ((__u32)( \
|
||||
(((__u32)(x) & (__u32)0x00ff00ffUL) << 8) | \
|
||||
(((__u32)(x) & (__u32)0xff00ff00UL) >> 8)))
|
||||
|
||||
|
|
@ -43,25 +43,25 @@
|
|||
* ___swab16, ___swab32, ___swab64, ___swahw32, ___swahb32
|
||||
*/
|
||||
|
||||
static inline __attribute_const__ __u16 ___swab16(__u16 val)
|
||||
static inline __attribute_const__ __u16 __fswab16(__u16 val)
|
||||
{
|
||||
#ifdef __arch_swab16
|
||||
return __arch_swab16(val);
|
||||
#else
|
||||
return __const_swab16(val);
|
||||
return ___constant_swab16(val);
|
||||
#endif
|
||||
}
|
||||
|
||||
static inline __attribute_const__ __u32 ___swab32(__u32 val)
|
||||
static inline __attribute_const__ __u32 __fswab32(__u32 val)
|
||||
{
|
||||
#ifdef __arch_swab32
|
||||
return __arch_swab32(val);
|
||||
#else
|
||||
return __const_swab32(val);
|
||||
return ___constant_swab32(val);
|
||||
#endif
|
||||
}
|
||||
|
||||
static inline __attribute_const__ __u64 ___swab64(__u64 val)
|
||||
static inline __attribute_const__ __u64 __fswab64(__u64 val)
|
||||
{
|
||||
#ifdef __arch_swab64
|
||||
return __arch_swab64(val);
|
||||
|
|
@ -70,25 +70,25 @@ static inline __attribute_const__ __u64 ___swab64(__u64 val)
|
|||
__u32 l = val & ((1ULL << 32) - 1);
|
||||
return (((__u64)___swab32(l)) << 32) | ((__u64)(___swab32(h)));
|
||||
#else
|
||||
return __const_swab64(val);
|
||||
return ___constant_swab64(val);
|
||||
#endif
|
||||
}
|
||||
|
||||
static inline __attribute_const__ __u32 ___swahw32(__u32 val)
|
||||
static inline __attribute_const__ __u32 __fswahw32(__u32 val)
|
||||
{
|
||||
#ifdef __arch_swahw32
|
||||
return __arch_swahw32(val);
|
||||
#else
|
||||
return __const_swahw32(val);
|
||||
return ___constant_swahw32(val);
|
||||
#endif
|
||||
}
|
||||
|
||||
static inline __attribute_const__ __u32 ___swahb32(__u32 val)
|
||||
static inline __attribute_const__ __u32 __fswahb32(__u32 val)
|
||||
{
|
||||
#ifdef __arch_swahb32
|
||||
return __arch_swahb32(val);
|
||||
#else
|
||||
return __const_swahb32(val);
|
||||
return ___constant_swahb32(val);
|
||||
#endif
|
||||
}
|
||||
|
||||
|
|
@ -98,8 +98,8 @@ static inline __attribute_const__ __u32 ___swahb32(__u32 val)
|
|||
*/
|
||||
#define __swab16(x) \
|
||||
(__builtin_constant_p((__u16)(x)) ? \
|
||||
__const_swab16((x)) : \
|
||||
___swab16((x)))
|
||||
___constant_swab16(x) : \
|
||||
__fswab16(x))
|
||||
|
||||
/**
|
||||
* __swab32 - return a byteswapped 32-bit value
|
||||
|
|
@ -107,8 +107,8 @@ static inline __attribute_const__ __u32 ___swahb32(__u32 val)
|
|||
*/
|
||||
#define __swab32(x) \
|
||||
(__builtin_constant_p((__u32)(x)) ? \
|
||||
__const_swab32((x)) : \
|
||||
___swab32((x)))
|
||||
___constant_swab32(x) : \
|
||||
__fswab32(x))
|
||||
|
||||
/**
|
||||
* __swab64 - return a byteswapped 64-bit value
|
||||
|
|
@ -116,8 +116,8 @@ static inline __attribute_const__ __u32 ___swahb32(__u32 val)
|
|||
*/
|
||||
#define __swab64(x) \
|
||||
(__builtin_constant_p((__u64)(x)) ? \
|
||||
__const_swab64((x)) : \
|
||||
___swab64((x)))
|
||||
___constant_swab64(x) : \
|
||||
__fswab64(x))
|
||||
|
||||
/**
|
||||
* __swahw32 - return a word-swapped 32-bit value
|
||||
|
|
@ -127,8 +127,8 @@ static inline __attribute_const__ __u32 ___swahb32(__u32 val)
|
|||
*/
|
||||
#define __swahw32(x) \
|
||||
(__builtin_constant_p((__u32)(x)) ? \
|
||||
__const_swahw32((x)) : \
|
||||
___swahw32((x)))
|
||||
___constant_swahw32(x) : \
|
||||
__fswahw32(x))
|
||||
|
||||
/**
|
||||
* __swahb32 - return a high and low byte-swapped 32-bit value
|
||||
|
|
@ -138,8 +138,8 @@ static inline __attribute_const__ __u32 ___swahb32(__u32 val)
|
|||
*/
|
||||
#define __swahb32(x) \
|
||||
(__builtin_constant_p((__u32)(x)) ? \
|
||||
__const_swahb32((x)) : \
|
||||
___swahb32((x)))
|
||||
___constant_swahb32(x) : \
|
||||
__fswahb32(x))
|
||||
|
||||
/**
|
||||
* __swab16p - return a byteswapped 16-bit value from a pointer
|
||||
|
|
|
|||
Загрузка…
Ссылка в новой задаче