解释具体的 C#define 是如何工作的

Question

我一直在查看http://www.netlib.org/fdlibm/ 的一些代码以了解某些功能是如何工作的，并且我正在查看 e_log.c 的代码以及它的某些部分代码：

hx = __HI(x);       /* high word of x */
lx = __LO(x);       /* low  word of x */

__HI(x) 和 __LO(x) 的代码是：

#define __HI(x) *(1+(int*)&x)
#define __LO(x) *(int*)&x

我真的不明白，因为我不熟悉这种类型的 C。有人可以向我解释一下 __HI(x) 和 __LO(x) 在做什么吗？

在函数的代码后面还有一条语句：

__HI(x) = hx|(i^0x3ff00000);

谁能给我解释一下：

• 如何使函数等于某物（我通常使用 python，所以我真的不知道发生了什么）？
• __HI(x) 和 __LO(x) 在做什么？
• 程序中x的“高位字”和“低位字”是什么意思？

我分析的最终目的是理解这段代码，以便将其移植到 Python 实现中

Answer 1

这些宏使用与编译器相关的属性来访问double 类型的表示。

在 C 中，除了位域之外的所有对象都表示为字节序列。您正在查看的 fdlibm 代码专为以下实现而设计：int 是四个字节，double 类型使用 IEEE-754 浮点规范定义的格式中的八个字节表示。该格式称为 binary64 或 IEEE-754 基本 64 位二进制浮点。它还设计用于 C 编译器保证支持通过指针转换的别名的实现。 （C 标准不保证这一点，但 C 实现可能支持它。）

考虑一个名为x 的double 对象。鉴于这些宏：

#define __HI(x) *(1+(int*)&x)
#define __LO(x) *(int*)&x

在源代码中使用__LO(x) 时，将其替换为*(int*)&x。 &x 采用x 的地址。 x 的地址类型为 double *。演员(int *) 将其转换为int *，一个指向int 的指针。然后* 取消引用这个指针，导致对int 的引用，它位于x 的低地址部分。

在源代码中使用__HI(x) 时，(int*)&x 再次指向x 的低地址部分。添加 1 会将其更改为指向高地址部分。然后* 取消对它的引用，从而导致对位于高地址部分的int 的引用。

fdlibm 中的例程是特殊的数学例程。要进行操作，他们需要检查和修改代表double 值的字节。 __LO 和 __HI 宏为他们提供了这种访问权限。

__HI 和 __LO 的这些定义适用于以小端顺序存储 double 值的实现（双精度的“最低有效”部分位于较低地址的内存位置）。 fdlibm 代码可能包含大端系统的替代定义，可能由某些#if 语句选择。

在代码__HI(x) = hx|(i^0x3ff00000); 中，值0x3ff00000 是位掩码，用于对double 值的指数（和有效数字的一部分）进行编码。没有上下文，我们无法准确地说出这里发生了什么，但代码似乎正在将hx 与来自i 的一些值合并。它可能正在完成对表示它正在创建的新 double 值的字节的一些计算，并将这些字节存储在 double 对象的“高”部分中。

Answer 2

我添加回复以整合已经存在的回复（而不是替代）。

hx = __HI(x);       /* high word of x */
lx = __LO(x);       /* low  word of x */

注释很有用...即使在这种情况下宏名称可能足够清晰。 “high”和“low”指的是整数表示的两半，通常是 16 位或 32 位，因为对于 8 位 int，使用的术语是“nibble”。

如果我们取一个 16 位无符号整数，范围从 0 到 65535，或十六进制 0x0000 到 0xFFFF，例如 0x1234，则两半是：

  0x1234
      ^^-------------------- lower half, or "low"
    ^^---------------------- upper half, or "high"

请注意，“较低”表示不太重要的部分。假设 16 位，获得两半的正确方法是与 0xFF 进行逻辑（按位）与得到 lo()，然后右移 8 位（除以 256）以获得高电平。

现在，在 CPU 内部，数字 0x1234 被写入两个连续的位置，如果是大端，则为 0x12，然后是 0x34，或者如果是小端，则为 0x34，然后是 0x12。鉴于此，其他方法可以读取单半部分，直接从内存中读取正确的部分，无需计算。要在小端机器中获取 0x1234 的 lo()，可以读取第一个位置的单个字节。

来自问题：

#define __HI(x) *(1+(int*)&x)
#define __LO(x) *(int*)&x

__LO 被定义为按位与（确定方式），而 __HI 直接在内存中窥视（不太确定）。这很奇怪，因为似乎要分成两部分的整数具有机器字大小的两倍。如果机器是 32 位，则要拆分的整数是 64 位长。还有一个警告：这些宏可以读取两半，但也可以用来分别写入两半。其实从问题来看：

__HI(x) = hx|(i^0x3ff00000);

结果是只设置 x 的 HI 部分（高位，最重要）。还要注意使用的值 0x3FFF0000，这似乎表明 x 是 128 位，因为用于生成它的 一半 的掩码是 64 位长。

希望这足够清楚，可以将 C 转换为 python。您应该使用 128 位长的整数。当需要获取 LO() 部分时，使用按位与 0xFFFFFFFF；要获得 HI()，请右移 64 次或进行等效除法。

当 HI 和 LO 位于赋值的左侧时，只写入一半的值，您应该分别构造两半并将它们相加（或按位或一起） .

希望对你有帮助...

Answer 3

#define A B

是一个预处理器指令，它在编译之前将整个源代码中的文字 A 替换为文字 B。

#define A(x) B

是一个类似函数的预处理器宏，它使用参数x 来进行参数化预处理器替换。在这种情况下，B 也可以是 x 的函数。

您的宏

#define __HI(x) *(1+(int*)&x)
#define __LO(x) *(int*)&x

// called as
__HI(x) = hx|(i^0x3ff00000);

由于只是代码替换的问题，因此分配是完全合法的。为什么？因为在这种情况下，宏在两种情况下都被 R-value 替换。

在这两种情况下，右值都是int 类型的变量：

• 获取 x 的地址
• 将其转换为指向 int 的指针
• 尊重它（在__LO()的情况下）
• 在__HI ()的情况下加1，然后顺从它。

它实际指向的内容取决于架构，因为指针算法依赖于架构。还必须考虑字节序。

我们可以说的是，它们的设计目的是为了访问 lower 和 higher 两半 大小为 2*sizeof (int) big 的数据类型（因此，例如，如果整数数据是 32 位宽，它们将允许访问低 32 字节和高 32 字节）。此外，从宏名上我们了解到它是一个little-endian架构（LSB在前）。

---

为了移植到包含此宏的 Python 代码，您需要在更高级别进行，因为 Python 不支持指针。

这些提示并不能解决您的具体任务，而是为您提供了一个工作方法来完成这个任务和类似的：

• 了解宏功能的一种方法是检查它是如何被预处理器实际翻译的。这可以通过-E 编译器选项在大多数编译器上完成。
• 使用调试器了解功能：在调用宏之前设置断点，并分析其对地址和变量的影响。