typeorder.h学习

在typeorder.h头文件中，主要定义了下面几个函数，__u32 ___arch__swab32(__u32 val),___arch__swab64(__u64 val)；这两个函数的含义基本上是将32位寄存器中的字节次序变反，将64位寄存器中的字节次序变反。

举个列子，有一个以16进制表示的32位变量，a=0x12345678;其中由于其是十六进制的，所以12占一个字节，34占一个字节，56占一个字节，78占一个字节，则执行上述___arch__swab32(__u32 val)函数之后，其字节次序变反，就变成了a=0x78563412了。

下面是tyepeorder.h的源代码，其中的解释以及学习部分都在注释当中，中间在处理64位的时候，有一段代码我看到就会感到很高兴，在注释中会有体现的。

#ifndef _I386_BYTEORDER_H
#define _I386_BYTEORDER_H

#include <asm/types.h>
#include <linux/compiler.h>

#ifdef __GNUC__

/* For avoiding bswap on i386 */
//未实现
#ifdef __KERNEL__
#endif

//该内联函数的作用是将x的字节次序反转
static __inline__ __attribute_const__ __u32 ___arch__swab32(__u32 x)
{
//bswap指令 是将32位寄存器中的字节的次序变反
#ifdef CONFIG_X86_BSWAP  //如果定义了bswap指令，则直接执行该指令
    __asm__("bswap %0" : "=r" (x) : "0" (x));

//xchgb：交换字或者是字节，至少有一个操作书是寄存器，段寄存器不能作为操作数
#else
    /*
     * 思想就是先交换低字节，将低字节循环左移16位，高字节被换到了低字节位置，再交换字节
     */
    __asm__("xchgb %b0,%h0\n\t" /* swap lower bytes,*/
        "rorl $16,%0\n\t"  /* swap words       */
        "xchgb %b0,%h0"     /* swap higher bytes    */
        :"=q" (x)
        : "0" (x));
#endif
    return x;
}

//该内联函数的作用是将64位字节的次序变反
/**
 * 他的思想是：
 * 首先，将64位的先变成两个32位的保存到一个结构中，
 * 同时与一个64位的变量保存到一个共同体中，在
 * 这里，真心能够感受到内核代码的能省内存尽量省的优雅了。
 * 虽然说这是一种不太美观的强制类型转换，直接将类型省了，
 * 但是这样的处理还是非常棒的。
 *
 * 如果定义了bswap汇编指令，则现将其中的两个32位的变量的字节交换，
 * 再将两个32位的字节交换。
 * 如果没有定义bswap指令，则先对其中的两个32位的变量执行上面的
 * ___arch__swab32函数，最后再将这两函数个变量交换
 *
 */
static __inline__ __attribute_const__ __u64 ___arch__swab64(__u64 val)
{
    union {
        struct { __u32 a,b; } s;
        __u64 u;
    } v;

    v.u = val;
#ifdef CONFIG_X86_BSWAP
    asm("bswapl %0 ; bswapl %1 ; xchgl %0,%1"
        : "=r" (v.s.a), "=r" (v.s.b)
        : "0" (v.s.a), "1" (v.s.b));
#else
   v.s.a = ___arch__swab32(v.s.a);
    v.s.b = ___arch__swab32(v.s.b);
    asm("xchgl %0,%1" : "=r" (v.s.a), "=r" (v.s.b) : "0" (v.s.a), "1" (v.s.b));
#endif
    return v.u;
} 

/* Do not define swab16.  Gcc is smart enough to recognize "C" version and
   convert it into rotation or exhange.  */
/* 不用定义16位的字节变反函数，因为gcc是非常聪明的，他能够识别“C”版本，并且
   将其转化成旋转或者是交换 */

#define __arch__swab64(x) ___arch__swab64(x)
#define __arch__swab32(x) ___arch__swab32(x)

#define __BYTEORDER_HAS_U64__

#endif /* __GNUC__ */

#include <linux/byteorder/little_endian.h>

#endif /* _I386_BYTEORDER_H */

学了之前的GCC内嵌汇编之后，看其中的汇编的时候就不会那么吃力了。