__safe_cmp定义为minmax. h

#define __safe_cmp(x, y) \
    (__typecheck(x, y) && __no_side_effects(x, y))
#define __no_side_effects(x, y) \
    (__is_constexpr(x) && __is_constexpr(y))
#define __typecheck(x, y) \
    (!!(sizeof((typeof(x) *)1 == (typeof(y) *)1)))
#define __is_constexpr(x) \
    (sizeof(int) == sizeof(*(8 ? ((void *)((long)(x) * 0l)) : (int *)8)))

据我了解，

• 此宏用于在编译过程中进行检查，以便在运行时不会出现不兼容的意外
• 如果在编译过程中没有警告，这个宏的结果应该总是1（true）

我还查看了Linux Kernel's __is_constexpr Macro中关于__is_constexpr的讨论
还有一些项目不清楚

• __typecheck的返回值被sizeof Package ，目的只是将结果保留为常量表达式？也就是说==操作符不作为常量表达式返回？在c11标准6.5.9中，它说返回的类型是int

结果的类型为int。对于任何一对操作数，只有一个关系为真

• 雌兔（type（x））1 ==（typeof（y））1总是返回1？在6.5.9中，它还说两者都是指向同一个对象的指针（包括指向对象的指针和在其开头的子对象）或函数，这意味着如果指针的值相同，则指针应该相等？？即使类型不同？？我测试过（int，long），（int，struct），（int，void），（long，int*）等等用这个表达式，在linux下都返回1，这个条件有false的情况吗？

5否则，至少有一个操作数是指针。如果一个操作数是指针，另一个是空指针常量，则空指针常量转换为指针的类型。如果一个操作数是指向对象类型的指针，另一个是指向void的限定或非限定版本的指针，则前者转换为后者的类型。
6两个指针比较相等当且仅当两者都是空指针，两者都是指向同一对象的指针（包括指向对象的指针和在其开头的子对象）或函数，两者都是指向同一数组对象的最后一个元素之后的一个元素的指针或者一个是指向一个数组对象末尾的指针，另一个是指向另一个数组对象的开始的指针，该数组对象恰好紧跟在地址空间中第一个数组对象之后

• 如果第1项和第2项是正确的，sizeof（equal expr）是将“equal expr”的结果转换为整数常量表达式，为什么需要这样做？我认为sizeof是将结果转换为true（即使为false），这样宏将始终返回true。我注意到评论说保持常量表达式避免VLA警告？如果没有常量表达式结果保留，是否有任何例子？
• 在__is_constexpr，“（long）（x）* 0 l”中，当x是常量表达式时，它将返回null指针常量，表达式将返回（int ）null（使用第三个操作数的类型），在www.example.com的Linux Kernel's __is_constexpr Macro中提到6.5.15.6，如果表达式类似于（长）（x++） 01，其也应该为空，但它不是一个空指针常量，所以结果是（void ）null？然后sizeof（（void *））== 1（sizeof（void））。如何从代码级别验证这种差异，因为没有sizeof %p的printf似乎是相同的

#include <stdio.h>

#define check(x)      ((void *)((long)(x) * 0l))
#define _check(x)     (8 ? check(x) : (int *)8)
#define __check(x)    sizeof(*(_check(x)))

int main(int args, char** argv)
{
  int x = 0;

  printf("%p\n", check(x++));    // (nil)
  printf("%p\n", check(1));      // (nil)

  printf("%p\n", _check(x++));   // (nil)
  printf("%p\n", _check(1));     // (nil)

  printf("%ld\n", __check(x++)); // 1
  printf("%ld\n", __check(1));   // 4

  return 0;
}

• 另一个问题是为什么在c11中第二个操作数是空指针常量时使用第三个操作数的类型作为返回类型。NULL在linux中被定义为（（void ）0）并且不指向任何真实的对象，为什么不直接使用void 作为返回类型？
• 在typecheck. h中还定义了一个名为typecheck的函数。这两个函数之间的区别是什么，实现也是为了比较x和y'类型之间的指针，在编译过程中生成警告/错误，并始终返回1，这是一个常量表达式。

#define typecheck(type,x) \
({    type __dummy; \
  typeof(x) __dummy2; \
  (void)(&__dummy == &__dummy2); \  // always false?
  1; \
})

顺便问一句，除了c11，有没有什么文档或书籍来解释这些问题？
感谢您的帮助！

更新：
关于__的问题是_constexpr

int main(int args, char** argv)
{

    int x = 1;
    int a = (long)x * 0l;
    int b = (long)1 * 0l;

    return 0;
}
0000000000001129 <main>:
    1129:   f3 0f 1e fa             endbr64 
    112d:   55                      push   %rbp
    112e:   48 89 e5                mov    %rsp,%rbp
    1131:   89 7d ec                mov    %edi,-0x14(%rbp)
    1134:   48 89 75 e0             mov    %rsi,-0x20(%rbp)
    1138:   c7 45 f4 01 00 00 00    movl   $0x1,-0xc(%rbp)
    113f:   c7 45 f8 00 00 00 00    movl   $0x0,-0x8(%rbp)
    1146:   c7 45 fc 00 00 00 00    movl   $0x0,-0x4(%rbp)
    114d:   b8 00 00 00 00          mov    $0x0,%eax
    1152:   5d                      pop    %rbp
    1153:   c3                      ret

上面的代码显示，2个表达式在编译过程中被翻译为0，似乎是一样的。
在gcc（版本11.3.0）中，下面的代码可以在c-typeck. c中找到，

static bool
null_pointer_constant_p (const_tree expr)
{
  /* This should really operate on c_expr structures, but they aren't
     yet available everywhere required.  */
  tree type = TREE_TYPE (expr);
  return (TREE_CODE (expr) == INTEGER_CST
      && !TREE_OVERFLOW (expr)
      && integer_zerop (expr)
      && (INTEGRAL_TYPE_P (type)
          || (TREE_CODE (type) == POINTER_TYPE
          && VOID_TYPE_P (TREE_TYPE (type))
          && TYPE_QUALS (TREE_TYPE (type)) == TYPE_UNQUALIFIED)));
}

根据cc 1的调试结果，

• 当检查TREE_CODE（expr）时，int a =（long）x * 0 l被视为MULT_EXPR，false
• 当检查TREE_CODE（expr）时，int B =（long）1 * 0 l被视为INTEGER_CST，true

第二个表达式在编译时是NULL指针常量，然后似乎与三元条件运算符的规则相匹配。
我不熟悉海合会内部，不确定分析是否正确。

根据Nate Eldredge的回答更新。非常感谢Nate Eldredge的病人在细节中回答所有问题。

• 使用sizeof的目的是避免计算expr

1.我认为两个表达式在linux平台上用gcc编译后的汇编结果是一样的，然后假设在那之后应该没有区别
1.根据答案。“==”表达式的求值结果是实现定义的，可以由编译器本身优化，而不是强制性的。在linux平台上使用gcc的结果可能看起来不错，可能与其他编译器和平台不一样

1.这里的规则是，如果结果不是决定性的，更重要的是如果结果不需要，只要保持expr不求值即可。例如，使用sizeof等。typecheck中的第3行为false，在某些情况下甚至在运行时也可能运行

• for __is_constexpr

1. sizeof与上面提到的相同，也区分指针类型，sizeof（（void））和sizeof（（int））
   1.我认为（（long）（x）* 0l）应该被编译器优化，计算为0l，首先转换为（void*）0，然后expr也应该是空指针常量，根据gcc中的调试，expr不是常量表达式，因为x不是行列式，即使结果似乎是0l，然后表达式可以用来区分常量表达式或不是常量表达式

• 当第二个操作数返回空指针常量时，为什么使用第三个操作数的类型而不是void*

1.根据答案，当类型不兼容时也发出警告
1.我认为我需要更多地考虑6.5.15p8，原始描述是如果一个操作数是空指针常量，则将使用另一个操作数的类型。（void*）（（长）（x++）* 0l）"，似乎返回“我想，如果空指针是常量，直接返回它（只是不使用另一个操作数的类型），如果为false，则直接返回（int*）
1.还需要更仔细地阅读6.2.7
再次感谢Nate Eldredge的耐心和友好的回复。