如何从Java字节码中识别三元运算符及嵌套三元运算符

问题1：如何判断一段if语句对应三元运算符？是否可基于栈变量进行判断？ #

三元运算符condition ? expr1 : expr2编译为字节码时，会生成固定的控制流+栈行为结构，可通过以下规则判断，栈变量分析是核心验证手段之一：

核心判定规则 #

• 控制流特征：
  1. 存在一条ifxx类指令（如if_icmpgt、ifne），将代码分支为两个块：分别对应三元的expr1和expr2
  2. 两个分支块的末尾均通过goto指令跳转到同一个汇合点，后续代码复用该分支的结果
  3. 两个分支块执行后，操作数栈会压入同类型的单个值（即三元运算的结果）
• 栈变量辅助验证：
  在ifxx指令执行前，操作数栈弹出条件判断所需的操作数；分支执行完毕后，汇合点处的栈深度会恢复到ifxx执行前的深度+1（因为压入了结果值）。同时，汇合点后的代码会直接使用栈顶值，不会额外将其存储到局部变量（除非后续有赋值操作）。

结合示例验证 #

看你提供的结构化字节码，最内层的三元r.nextInt() > 4000 ? 1 : 0完全符合：

• [37 if_icmple]将代码分支到true块（44）和false块（40）
• true块压入iconst_0后goto 66，false块压入iconst_1后goto 66
• 66就是汇合点，后续代码直接使用栈顶的int值参与比较，完全匹配三元结构。

问题2：如何判断if语句操作数栈上消耗的值是三元运算符的结果？ #

可通过汇合点栈状态和后续代码的使用逻辑来精准判断：

关键判定逻辑 #

1. 汇合点栈一致性：
   if分支的两个块执行完毕后，汇合点处的操作数栈必须满足：
   • 栈深度完全相同
   • 栈顶元素的类型严格匹配（基本类型或引用类型一致）
     这个栈顶元素就是三元运算符的结果。
2. 后续代码的使用场景：
   该栈顶值会直接参与下一个运算（如示例中内层三元的结果用于和另一个三元结果做if_icmpge比较），或是被存储到局部变量（如示例末尾的istore指令），不会被无意义地丢弃。
3. 分支栈来源追踪：
   从汇合点反向追踪，两个分支块的最后一条有效指令（排除goto）必须是压栈指令（如iconst_、bipush、invokevirtual等），且压入的值就是对应分支的结果。

结合示例验证 #

示例中汇合点66处的栈顶值符合要求：

• false分支（块5）压入iconst_1，true分支（块4）压入iconst_0，类型均为int，栈深度一致
• 后续[66 aload]执行前，栈顶的int值就是该三元的结果，直接参与后续的比较运算。

示例代码 #

简单嵌套三元示例 #

((a>b ? 0 : 1 ) > (a > c ? 10 : 20) ? 100 : 101)

完整嵌套三元源代码 #

public void ddddd()
{
    int m,k, n, z;
    Random r = new Random();
    boolean p = (r.nextInt() > 100 || (30 > r.nextInt() ? (r.nextInt() > 4000 ? 1 : 0) : (r.nextInt() > 2000 ? 100 : 20)) <  (r.nextInt() > 1000 ? 0 : 1));
}

对应结构化字节码 #

7          astore] java/util/Random var1(1) = <init>(v0)
 [   9           aload] java/util/Random var1(1) = (stack_var)var1
 [  11   invokevirtual] I v11 = var1.nextInt()
 [  14          bipush] (I)v14 = 100
 if { // block_id: 16 16 => 89  parent_id: 0
    [  16       if_icmpgt] v11 > v14 : goto => 85
    if_false_block { // block_id: 15 19 => 89  parent_id: 16
        [  19          bipush] (I)v19 = 30
        [  21           aload] java/util/Random var1(1) = (stack_var)var1
        [  23   invokevirtual] I v23 = var1.nextInt()
        if { // block_id: 9 26 => 64  parent_id: 15
            [  26       if_icmple] v19 <= v23 : goto => 48
            if_false_block { // block_id: 8 29 => 45  parent_id: 9
                [  29           aload] java/util/Random var1(1) = (stack_var)var1
                [  31   invokevirtual] I v31 = var1.nextInt()
                [  34          sipush] (I)v34 = 4000
                if { // block_id: 6 37 => 45  parent_id: 8
                    [  37       if_icmple] v31 <= v34 : goto => 44
                    if_false_block { // block_id: 5 40 => 41  parent_id: 6
                        [  40        iconst_1] (I)v40 = 1
                        [  41            goto] goto: 66
                    }
                    if_true_block { // block_id: 4 44 => 45  parent_id: 6
                        [  44        iconst_0] (I)v44 = 0
                        [  45            goto] goto: 66
                    }
                }
            }
            if_true_block { // block_id: 7 48 => 64  parent_id: 9
                [  48           aload] java/util/Random var1(1) = (stack_var)var1
                [  50   invokevirtual] I v50 = var1.nextInt()
                [  53          sipush] (I)v53 = 2000
                if { // block_id: 3 56 => 64  parent_id: 7
                    [  56       if_icmple] v50 <= v53 : goto => 64
                    if_false_block { // block_id: 2 59 => 61  parent_id: 3
                        [  59          bipush] (I)v59 = 100
                        [  61            goto] goto: 66
                    }
                    if_true_block { // block_id: 1 64 => 64  parent_id: 3
                        [  64          bipush] (I)v64 = 20
                    }
                }
            }
        }
        [  66           aload] java/util/Random var1(1) = (stack_var)var1
        [  68   invokevirtual] I v68 = var1.nextInt()
        [  71          sipush] (I)v71 = 1000
        if { // block_id: 12 74 => 81  parent_id: 15
            [  74       if_icmple] v68 <= v71 : goto => 81
            if_false_block { // block_id: 11 77 => 78  parent_id: 12
                [  77        iconst_0] (I)v77 = 0
                [  78            goto] goto: 82
            }
            if_true_block { // block_id: 10 81 => 81  parent_id: 12
                [  81        iconst_1] (I)v81 = 1
            }
        }
        if { // block_id: 14 82 => 89  parent_id: 15
            [  82       if_icmpge] v40 >= v77 : goto => 89
            [  85        iconst_1] (I)v85 = 1
            [  86            goto] goto: 90
            if_true_block { // block_id: 13 89 => 89  parent_id: 14
                [  89        iconst_0] (I)v89 = 0
            }
        }
    }
 }
 [  90          istore] I var2(1) = (stack_var)var2
 [  92          return] return

内容的提问来源于stack exchange，提问作者Neo