Linux应用程序移植到64位系统 （2）

    16 进制的常量通常都用作掩码或特殊位的值。如果一个没有后缀的 16 进制的常量是 32 位的，并且其高位被置位了，那么它就可以作为无符号整型进行定义。

    例如，常数 OxFFFFFFFFL 是一个有符号的 long 类型。在 32 位系统上，这会将所有位都置位（每位全为 1），但是在 64 位系统上，只有低 32 位被置位了，结果是这个值是 0x00000000FFFFFFFF.

    如果我们希望所有位全部置位，那么一种可移植的方法是定义一个有符号的常数，其值为 -1.这会将所有位全部置位，因为它采用了二进制补码算法。

long x = -1L;
            

1L << ((sizeof(long) * 8) - 1);
            

    Endianism 是指用来存储数据的方法，它定义了整数和浮点数据类型中是如何对字节进行寻址的。

    Little-endian 是将低位字节存储在内存的低地址中，将高位字节存储在内存的高地址中。

    Big-endian 是将高位字节存储在内存的低地址中，将低位字节存储在内存的高地址中。

    表 3 给出了一个 64 位长整数的布局示例。

    表 3. 64 位 long int 类型的布局

    表 4. 0x12345678 在 big-endian 系统上的布局

如果将 0x12345678 当作两个半字来看待，分别是 0x1234 和 0x5678，那么就会看到在 big endian 机器上是下面的情况：

    表 5. 0x12345678 在 big-endian 系统上当作两个半字来看待的情况

    表 6. 0x12345678 在 little-endian 系统上的布局

    表 7. 0x12345678 在 little-endian 系统上作为两个半字看到的情况

    下面的 C 程序在一台 big endian 机器上进行编译和运行时会打印 “Big endian”，在一台 little endian 机器上进行编译和运行时会打印 “Little endian”。

    清单 2. big endian 与 little endian

#include 
            main () {
            int i = 0x12345678;
            if (*(char *)&i == 0x12)
            printf ("Big endian\n");
            else if (*(char *)&i == 0x78)
            printf ("Little endian\n");
            }
            

    使用位掩码时
    对象的间接指针地址部分

    在 C 和 C++ 中有位域来帮助处理 endian 的问题。我建议使用位域，而不要使用掩码域或 16 进制的常量。有几个函数可以用来将 16 位和 32 位数据从 “主机字节顺序” 转换成 “网络字节顺序”。例如，htonl （3）、ntohl （3） 用来转换 32 位整数。类似地，htons （3）、ntohs （3） 用来转换 16 位整数。然而，对于 64 位整数来说，并没有标准的函数集。但是在 big endian 和 little endian 系统上，Linux 都提供了下面的几个宏：

    bswap_16
    bswap_32
    bswap_64

    类型定义

    建议您不要使用 C/C++ 中那些在 64 位系统上会改变大小的数据类型来编写应用程序，而是使用一些类型定义或宏来显式地说明变量中所包含的数据的大小和类型。有些定义可以使代码的可移植性更好。

    ptrdiff_t：
    这是一个有符号整型，是两个指针相减后的结果。

    size_t：
    这是一个无符号整型，是执行 sizeof 操作的结果。这在向一些函数（例如 malloc （3））传递参数时使用，也可以从一些函数（比如 fred （2））中返回。

    int32_t、uint32_t 等：
    定义具有预定义宽度的整型。

    intptr_t 和 uintptr_t：
    定义整型类型，任何有效指针都可以转换成这个类型。

    例 1：

    在下面这条语句中，在对 bufferSize 进行赋值时，从 sizeof 返回的 64 位值被截断成了 32 位。

    int bufferSize = （int） sizeof （something）；

    解决方案是使用 size_t 对返回值进行类型转换，并将其赋给声明为 size_t 类型的 bufferSize，如下所示：

    size_t bufferSize = （size_t） sizeof （something）；

    例 2：

    在 32 位系统上，int 和 long 大小相同。由于这一点，有些开发人员会交换使用这两种类型。这可能会导致指针被赋值给 int 类型，或者反之。但是在 64 位的系统上，将指针赋值给 int 类型会导致截断高 32 位的值。

    解决方案是将指针作为指针类型或为此而定义的特殊类型进行存储，例如 intptr_t 和 uintptr_t.

    位移

    无类型的整数常量就是 （unsigned） int 类型的。这可能会导致在位移时出现被截断的问题。

    例如，在下面的代码中，a 的最大值可以是 31.这是因为 1 << a 是 int 类型的。

    long t = 1 << a；

    要在 64 位系统上进行位移，应该使用 1L，如下所示：

    long t = 1L << a；

    字符串格式化

    函数 printf （3） 及其相关函数都可能成为问题的根源。例如，在 32 位系统上，使用 %d 来打印 int 或 long 类型的值都可以，但是在 64 位平台上，这会导致将 long 类型的值截断成低 32 位的值。对于 long 类型的变量来说，正确的用法是 %ld.

    类似地，当一个小整数（char、short、int）被传递给 printf （3） 时，它会扩展成 64 位的，符号会适当地进行扩展。在下面的例子中，printf （3） 假设指针是 32 位的。

    char *ptr = &something；printf （%x\n"， ptr）；

    上面的代码在 64 位系统上会失败，它只会显示低 4 字节的内容。

    这个问题的解决方案是使用 %p，如下所示；这在 32 位和 64 位系统上都可以很好地工作：

    char *ptr = &something；printf （%p\n"， ptr）；

    函数参数

    在向函数传递参数时需要记住几件事情：

    在参数的数据类型是由函数原型定义的情况中，参数应该根据标准规则转换成这种类型。

    在参数类型没有指定的情况中，参数会被转换成更大的类型。

    在 64 位系统上，整型被转换成 64 位的整型值，单精度的浮点类型被转换成双精度的浮点类型。

    如果返回值没有指定，那么函数的缺省返回值是 int 类型的。

    在将有符号整型和无符号整型的和作为 long 类型传递时就会出现问题。考虑下面的情况：

    清单 3. 将有符号整型和无符号整型的和作为 long 类型传递

long function (long l);
            int main () {
            int i = -2;
            unsigned k = 1U;
            long n = function (i + k);
            }
            

上面这段代码在 64 位系统上会失败，因为表达式 (i + k) 是一个无符号的 32 位表达式，在将其转换成 long 类型时，符号并没有得到扩展。解决方案是将一个操作数强制转换成 64 位的类型。

在基于寄存器的系统上还有一个问题：系统采用寄存器而不是堆栈来向函数传递参数。考虑下面的例子：

float f = 1.25;
printf ("The hex value of %f is %x", f, f);

在基于堆栈的系统中，这会打印对应的 16 进制值。但是在基于寄存器的系统中，这个 16 进制的值会从一个整数寄存器中读取，而不是从浮点寄存器中读取。

解决方案是将浮点变量的地址强制转换成一个指向整型类型的指针，如下所示：

printf ("The hex value of %f is %x", f, *(int *)&f);

    结束语

    主流的硬件供应商最近都在扩充自己的 64 位产品，这是因为 64 位平台可以提供更好的性能、价值和可伸缩性。32 位系统的限制，特别是 4GB 的虚拟内存上限，已经极大地刺激很多公司开始考虑迁移到 64 位平台上。了解如何将应用程序移植到 64 位体系结构上可以帮助我们编写可移植性更好且效率更高的代码。

     关于作者

    Harsha Adiga 就职于印度的 IBM Software Group，他参与了很多 Linux 和开放源码社区、工作组的工作。