postgres指令选择问题

[lfeng14]

• 描述
  postgres里面有涉及nan与0.0比较，毕昇生成的指令fmaxnm，应该使用fcmp指令。当前通过修改代码后规避。在 C 语言标准中，‌任何浮点数与 NaN 的比较（包括 ==、!=、>、<、>=、<=）均返回 false

  // postgresql geo_ops.c
  Datum
  dist_pc(FunctionCallInfo fcinfo)
  {
   Point *point = ((Point *) ((Pointer) ((fcinfo->args[0].value))));
   CIRCLE *circle = ((CIRCLE *) ((Pointer) ((fcinfo->args[1].value))));
   float8 result;
  
   result = float8_mi(point_dt(point, &circle->center),
          circle->radius);
  
          if (__builtin_isnan (result)) {
            return Float8GetDatum(result);
          }
  
   if (result < 0.0)
    result = 0.0;
  
   return Float8GetDatum(result);
  }
  

• demo: 如何d是-1 返回0.0；如果d是nan，返回nan；

  double f(double d) {
    if (d < 0.0) {
       return 0.0;
     }
    return d;
  }
  

• 构建命令：

  clang -S geo_ops-proce.c  -o geo_ops.s -O2; cat  geo_ops.s | grep -a1 fmaxnm
  /home/luofeng/BiSheng/BiSheng-Compiler-4.2.0/bin//clang -Wno-error=unused-command-line-argument -Wno-error=strict-prototypes -Wno-error=unused-but-set-variable -Wno-error=backend-plugin -O3 -mcpu=tsv110  -fuse-ld=lld  -mllvm -inline-threshold=2000 -Wl,-mllvm,-inline-threshold=2000 -fprofile-use=/media/bisheng.profdata -Wall -Wmissing-prototypes -Wpointer-arith -Wno-error=unused-command-line-argument -Wno-error=strict-prototypes -Wno-error=unused-but-set-variable -Wno-error=backend-plugin -I. -I. -I../../../../src/include  -D_GNU_SOURCE -I/usr/include/libxml2   -S -o geo_ops-bs17.s geo_ops.c
  

[lfeng14]

• 问题找到了因为默认开启了-ffp-contract=fast，导致ir阶段多了contract，想问怎么影响到指令选择阶段 ？

  有问题生成的IR(多了contract )
    %79 = fcmp uno double %68, 0.000000e+00
    %80 = fcmp contract olt double %68, 0.000000e+00
    %81 = select i1 %80, double 0.000000e+00, double %68
    %82 = select i1 %79, double %68, double %81
    %83 = bitcast double %82 to i64
    ret i64 %83
  
  没问题生成的IR
  float8_mi.exit:                                   ; preds = %point_dt.exit, %land.lhs.true.i
    %36 = fcmp uno double %sub.i, 0.000000e+00
    %cmp = fcmp olt double %sub.i, 0.000000e+00
    %result.0 = select i1 %cmp, double 0.000000e+00, double %sub.i
    %retval.0.v = select i1 %36, double %sub.i, double %result.0
    %retval.0 = bitcast double %retval.0.v to i64
    ret i64 %retval.0
  

• 指令选择部分代码llvm/lib/CodeGen/GlobalISel/CombinerHelper.cpp：

  unsigned CombinerHelper::getFPMinMaxOpcForSelect(
      CmpInst::Predicate Pred, LLT DstTy,
      SelectPatternNaNBehaviour VsNaNRetVal) const {
    assert(VsNaNRetVal != SelectPatternNaNBehaviour::NOT_APPLICABLE &&
           "Expected a NaN behaviour?");
    // Choose an opcode based off of legality or the behaviour when one of the
    // LHS/RHS may be NaN.
    switch (Pred) {
    default:
      return 0;
    case CmpInst::FCMP_UGT:
    case CmpInst::FCMP_UGE:
    case CmpInst::FCMP_OGT:
    case CmpInst::FCMP_OGE:
      if (VsNaNRetVal == SelectPatternNaNBehaviour::RETURNS_OTHER)
        return TargetOpcode::G_FMAXNUM;
      if (VsNaNRetVal == SelectPatternNaNBehaviour::RETURNS_NAN)
        return TargetOpcode::G_FMAXIMUM;
      if (isLegal({TargetOpcode::G_FMAXNUM, {DstTy}}))
        return TargetOpcode::G_FMAXNUM;
      if (isLegal({TargetOpcode::G_FMAXIMUM, {DstTy}}))
        return TargetOpcode::G_FMAXIMUM;
      return 0;
    case CmpInst::FCMP_ULT:
    case CmpInst::FCMP_ULE:
    case CmpInst::FCMP_OLT:
    case CmpInst::FCMP_OLE:
      if (VsNaNRetVal == SelectPatternNaNBehaviour::RETURNS_OTHER)
        return TargetOpcode::G_FMINNUM;
      if (VsNaNRetVal == SelectPatternNaNBehaviour::RETURNS_NAN)
        return TargetOpcode::G_FMINIMUM;
      if (isLegal({TargetOpcode::G_FMINNUM, {DstTy}}))
        return TargetOpcode::G_FMINNUM;
      if (!isLegal({TargetOpcode::G_FMINIMUM, {DstTy}}))
        return 0;
      return TargetOpcode::G_FMINIMUM;
    }
  }
  

• clang -S geo_ops-proce.c -mllvm -opt-bisect-limit=36194 -o geo_ops.s -O2; cat geo_ops.s | grep -a1 fmaxnm
  通过控制 limit 跳过了 AArch64 Instruction Selection，编译器并不会报错。它只是停止了对该函数后续所有的转换。对于这个特定的函数 dist_cpoint，它可能就停留在 IR 状态，或者在生成 .s 文件时这个函数是空的。

• 以为是fp-contract=fast导致的，导致生成的IR带有contract关键字，有问题的，但是将不带contract的IR输入给毕昇编译器(基于llvm的下游版本)，生成的汇编也会带fmaxnum指令，所以排除选项-ffp-contract=fast导致的问题，问题可能在其他地方:

• 继续debug-only选项打印sdnode信息：

   llc -mtriple=aarch64     --debug-only=isel     -filter-print-funcs=dist_pc     geo_ops.ll -o geo_ops-bug.s |& tee ok.log
  
    Optimized legalized selection DAG: %bb.16 'dist_pc:'                                  
    SelectionDAG has 12 nodes:                                                          
      t0: ch,glue = EntryToken                                                          
      t2: f64,ch = CopyFromReg t0, Register:f64 %19                                     
            t24: f64 = fmaxnum t2, ConstantFP:f64<0.000000e+00>                         
            t18: f64 = AArch64ISD::FCMP t2, t2                                          
          t20: f64 = AArch64ISD::CSEL t2, t24, Constant:i32<6>, t18                     
    ------------------------------------------------------------------------------------
        t10: i64 = bitcast t20                                                          
      t12: ch,glue = CopyToReg t0, Register:i64 $x0, t10                                
      t13: ch = AArch64ISD::RET_GLUE t12, Register:i64 $x0, t12:1                       
        
    正常的
    Optimized legalized selection DAG: %bb.16 'dist_pc:'
    SelectionDAG has 14 nodes:                                            
      t0: ch,glue = EntryToken
      t2: f64,ch = CopyFromReg t0, Register:f64 %19
              t21: i32 = AArch64ISD::FCMP t2, ConstantFP:f64<0.000000e+00>
            t23: f64 = AArch64ISD::CSEL ConstantFP:f64<0.000000e+00>, t2, 
            t18: i32 = AArch64ISD::FCMP t2, t2                            
          t20: f64 = AArch64ISD::CSEL t2, t23, Constant:i32<6>, t18       
        t10: i64 = bitcast t20
      t12: ch,glue = CopyToReg t0, Register:i64 $x0, t10
      t13: ch = AArch64ISD::RET_GLUE t12, Register:i64 $x0, t12:1
  

• 如何怀疑是dagcombine ? 待补充

• 在 llc 运行期间，SelectionDAG 的生命周期如下：

  • 构建初始 DAG (Initial DAG)：从 LLVM IR 转换为原始节点。
  • DAGCombine 1：第一次合并（优化逻辑，不考虑硬件是否支持）。
  • 类型合法化 (Type Legalization)：比如把 i128 拆成两个 i64。
  • DAGCombine (Type Legalized)：类型变了，再合并一次。
  • 操作合法化 (Op Legalization)：比如 AArch64 不支持某个指令，就用函数调用代替。
  • DAGCombine (Optimized Legalized)：这是你最关注的阶段！ 硬件支持的指令都确定了，做最后一次合并优化。
  • 指令选择 (Instruction Selection / ISEL)：将这些优化后的通用节点翻译成具体的硬件指令（如 fmaxnm）

• 继续打印dagcombine 日志：llc -mtriple=aarch64 -debug-only=dagcombine -filter-print-funcs=dist_pc geo_ops.ll |& tee ok-dagcombine.log

    有问题
    Combining: t3: f64 = ConstantFP<0.000000e+00>                                       
                                                                                        
    Combining: t2: f64,ch = CopyFromReg t0, Register:f64 %19                            
                                                                                        
    Combining: t1: f64 = Register %19                                                   
                                                                                        
    Combining: t0: ch,glue = EntryToken                                                 
                                                                                        
    Combining: t14: f64 = AArch64ISD::CSEL ConstantFP:f64<0.000000e+00>, t2, Constant:i3
     ... into: t15: f64 = fmaxnum t2, ConstantFP:f64<0.000000e+00>                      
                                                                                        
    Combining: t15: f64 = fmaxnum t2, ConstantFP:f64<0.000000e+00>                      
    ------------------------------------------------------------------------------------
    ------------------------------------------------------------------------------------
                                                                                        
    Combining: t10: ch = AArch64ISD::RET_GLUE t9, Register:i64 $x0, t9:1                
                                                                                        
    Combining: t9: ch,glue = CopyToReg t0, Register:i64 $x0, t7                         
                                                                                        
    Combining: t7: i64 = bitcast t15                                                    
      
    没问题
      
    Combining: t3: f64 = ConstantFP<0.000000e+00>                                  
    
    Combining: t2: f64,ch = CopyFromReg t0, Register:f64 %19                       
    
    Combining: t1: f64 = Register %19                                              
    
    Combining: t0: ch,glue = EntryToken                                            
    
    Combining: t14: f64 = AArch64ISD::CSEL ConstantFP:f64<0.000000e+00>, t2, Consta
    -------------------------------------------------------------------------------
                                                                                   
    Combining: t13: i32 = Constant<4>                                              
                                                                                   
    Combining: t12: i32 = AArch64ISD::FCMP t2, ConstantFP:f64<0.000000e+00>        
    
    Combining: t10: ch = AArch64ISD::RET_GLUE t9, Register:i64 $x0, t9:1
    
    Combining: t9: ch,glue = CopyToReg t0, Register:i64 $x0, t7                    
    
    Combining: t7: i64 = bitcast t14   
    
  

• 原本有两个fcmp + csel指令都被dagcombine成fmaxnum + fmaxnum这才导致问题出现：

  Combining: t14: f64 = AArch64ISD::CSEL ConstantFP:f64<0.000000e+00>, t2, Constant:i32<2>, t12
   ... into: t15: f64 = fmaxnum t2, ConstantFP:f64<0.000000e+00>
  

  • 发生了什么： 编译器看到了一个 AArch64ISD::CSEL（条件选择）节点。
  • 编译器的推理： 它识别出这个 CSEL 的逻辑是：“如果比较结果满足条件（Constant:i32<2>，通常对应 OLT/小于），则选 0.0，否则选 t2”。
  • 结论： 编译器认为这在数学上完全等价于 max(t2, 0.0)。
  • 动作： 它贪婪地将这个三路操作（比较+两个分支）收缩成了单一的 fmaxnum 节点。这就是 Bug 的根源。 因为在 AArch64 硬件层面，fmaxnum 指令（FMAXNM）会为了性能“吞掉” NaN（如果一个是 NaN，返回另一个数字）。

[lfeng14]

• AI提问：

  t21: i32 = AArch64ISD::FCMP t2, ConstantFP:f64<0.000000e+00>
            t23: f64 = AArch64ISD::CSEL ConstantFP:f64<0.000000e+00>, t2, 
            t18: i32 = AArch64ISD::FCMP t2, t2                            
          t20: f64 = AArch64ISD::CSEL t2, t23, Constant:i32<6>, t18
  这几条指令如何实现
  
   if (__builtin_isnan (result)) {
  return Float8GetDatum(result);
  }
  
   if (result < 0.0)
    result = 0.0;
  
   return Float8GetDatum(result);
  

-AI回答：

首先，C 代码的逻辑是：

1. 如果 result 是 NaN → 直接返回 NaN（Float8GetDatum(result)）。
2. 否则，如果 result < 0.0 → 将 result 设为 0.0。
3. 返回 result。

对应的 DAG 节点如下（已补全缺失的条件码，推导为 ARMCC::LT）：

t21: i32 = AArch64ISD::FCMP t2, ConstantFP:f64<0.0>
t23: f64 = AArch64ISD::CSEL ConstantFP:f64<0.0>, t2, ARMCC::LT, t21
t18: i32 = AArch64ISD::FCMP t2, t2
t20: f64 = AArch64ISD::CSEL t2, t23, ARMCC::VS, t18

其中 t2 就是 C 代码中的 result。

---

第一步：比较 result 与 0.0（准备 t21）

t21 = FCMP t2, 0.0

• 比较 t2 与浮点常量 0.0，结果写入 NZCV 标志位。
• 标志含义（浮点比较）：
  • 若 t2 是 NaN → 置 V=1（无序），其他标志不定。
  • 若 t2 < 0.0 → 置 N=1, Z=0, C=0, V=0。
  • 若 t2 == 0.0 → 置 Z=1。
  • 若 t2 > 0.0 → 置 N=0, Z=0, C=1, V=0。
• t21 代表这组标志位（作为后续 CSEL 的输入）。

---

第二步：条件选择 0.0 或 result（t23）

t23 = CSEL 0.0, t2, LT, t21

• 条件码 LT（Less Than）：检查 N 标志为 1 且 V 标志为 0（即 t2 < 0.0 且不是 NaN）。
• 行为：
  • 如果条件 LT 满足（t2 < 0.0），则 t23 = 0.0。
  • 否则（t2 >= 0.0 或 t2 是 NaN），则 t23 = t2。
• 注意：t2 是 NaN 时，LT 不成立（因为无序），所以 t23 = t2（NaN）。这正好对应 C 代码中第一个 if 之前的状态——我们还没有处理 NaN，只是做了“小于 0 则归零”的变换，但 NaN 保持不变。

---

第三步：检测 result 是否为 NaN（t18）

t18 = FCMP t2, t2

• 比较 t2 与自身。
• 如果 t2 是正常数（非 NaN）→ 相等 → Z=1, V=0。
• 如果 t2 是 NaN → 比较结果是无序 → V=1（并可能 C=1，但无关紧要）。
• t18 保存这次比较的标志位。

---

第四步：最终选择（t20）

t20 = CSEL t2, t23, VS, t18

• 条件码 VS（Overflow / Unordered）：检查 V 标志是否为 1，即是否发生了无序比较（NaN）。
• 行为：
  • 如果 t2 是 NaN（V=1），则 t20 = t2（真值）。
  • 否则（t2 不是 NaN），则 t20 = t23（假值）。
• 而 t23 在非 NaN 情况下已经等于 (t2 < 0.0 ? 0.0 : t2)。

---

整体等价逻辑

综合起来，t20 的值完全匹配 C 代码：

t20 = isNaN(t2) ? t2 : (t2 < 0.0 ? 0.0 : t2)

这正是：

1. 如果是 NaN → 返回 NaN；
2. 否则，如果小于 0 → 返回 0.0；
3. 否则返回 t2 本身。

---

补充说明

• 为什么第一个 CSEL 的条件码是 LT？
  因为 t2 < 0.0 时取 0.0，否则取 t2。如果用 GE（大于等于）则需要交换真假操作数，但逻辑等价。
• 为什么需要两次比较？
  因为 AArch64 的 CSEL 只能根据单次比较的标志做选择。为了同时处理“NaN 检测”和“小于 0 归零”，需要两次比较：一次用于与 0 比较，一次用于自比较（检测 NaN）。外层 CSEL 用 NaN 检测结果决定最终输出是原始值还是归零后的值。
• 如果 C 代码先判断 NaN 再归零，为什么 DAG 先归零再判断 NaN？
  因为归零操作（CSEL）在 NaN 输入下会输出 NaN（安全），然后外层 CSEL 再把它替换为原始 NaN。结果一致，且指令序列更优（避免了分支）。