带您看懂字节码指令(四):一条指令里有什么

在前三篇文章里 ⬇️ 我们借助 javap 命令查看了字节码指令:iload_1、iadd、iinc......

但 class 文件里存的是字节,一条指令到底占几个字节?操作保存在哪里?第三篇文章结尾留了两个问题------ldc、ldc_w、ldc2_w 分别取什么,以及 100 和 1000000 为什么走不同的指令------本文从规范 2.11 节的开头讲起,把指令拆到字节这一层,两个问题自然就有答案了。

一条指令 = 1 字节 opcode 加零或多个操作数

规范 2.11 节开头提到 ⬇️

A Java Virtual Machine instruction consists of a one-byte opcode specifying the operation to be performed, followed by zero or more operands supplying arguments or data that are used by the operation. Many instructions have no operands and consist only of an opcode.

每条指令的第一个字节是 opcode,操作数(如果有)紧跟在后面。规范接着给出了 JVM 解释器的主循环 ⬇️

Ignoring exceptions, the inner loop of a Java Virtual Machine interpreter is effectively

text 复制代码
do {
    atomically calculate pc and fetch opcode at pc;
    if (operands) fetch operands;
    execute the action for the opcode;
} while (there is more to do);

pc 从 0 开始,取一个字节的 opcode;这条指令如果带操作数,再把操作数取出来;执行;pc 指向下一条,重复。前三篇看的都是"执行"那一环,这一篇要看的是前两环:opcode 和操作数是怎么从字节流里取出来的。

opcode 只有 1 个字节,这是规范有意做的取舍 ⬇️

The decision to limit the Java Virtual Machine opcode to a byte and to forgo data alignment within compiled code reflects a conscious bias in favor of compactness, possibly at the cost of some performance in naive implementations. A one-byte opcode also limits the size of the instruction set. Not assuming data alignment means that immediate data larger than a byte must be constructed from bytes at run time on many machines.

1 个字节 8 位,最多 256 个编码,整个指令集的规模就被限在一字节里;换来的是紧凑------很多指令一个字节就是一条完整的指令。代价是:立即数超过一个字节时,只能在运行时从多个字节拼出来。2.11 节紧接着还规定:字节码只按单字节对齐,唯一的例外是 tableswitch 和 lookupswitch------它们的部分操作数要填充到 4 字节边界。这个例外为什么存在,留到讲控制流的那一篇再说。

换一组方法做解剖对象,五个方法覆盖了最常见的几种操作数形态 ⬇️

java 复制代码
class ShowBytes {
    int add(int a, int b) { return a + b; }
    int addTen(int i) { return i + 10; }
    int addThousand(int i) { return i + 1000; }
    void inc(int i) { i++; }
    int million() { return 1000000; }
}

先看 add,"零个操作数"的形态 ⬇️

text 复制代码
  int add(int, int);
    descriptor: (II)I
    flags: (0x0000)
    Code:
      stack=2, locals=3, args_size=3
         0: iload_1
         1: iload_2
         2: iadd
         3: ireturn

四条指令的偏移是 0、1、2、3------每条占 1 个字节。用十六进制查看器看 class 文件,add 的方法体就是 1b 1c 60 ac 这四个字节:iload_1 是 1b,iload_2 是 1c,iadd 是 60,ireturn 是 ac。四条指令一个操作数都没有,opcode 本身就是完整的指令。

javap 清单默认不显示这些字节,配套 demo 的字节流面板补上了这一层 ⬇️

每个格子是一个字节:左上是偏移,中间是十六进制,下面是这个字节在指令里扮演的角色。此刻 pc = 0,四条指令的边界用括线画了出来------javap 偏移列里的 0、1、2、3,和图里的指令分组一一对应。

操作数跟在 opcode 后面:bipush 和 sipush

addTen 里出现了第一个带操作数的指令 ⬇️

text 复制代码
  int addTen(int);
    descriptor: (I)I
    flags: (0x0000)
    Code:
      stack=2, locals=2, args_size=2
         0: iload_1
         1: bipush        10
         3: iadd
         4: ireturn

方法体一共 5 个字节:1b 10 0a 60 ac。bipush 的偏移是 1,iadd 的偏移却是 3------bipush 自己占了两个字节:opcode 10,加一个操作数字节 0a,也就是十进制的 10。bipush 被取出时,字节流面板上是这个样子 ⬇️

opcode 格子是蓝色,操作数格子是琥珀色边框------"取操作数"这一环取的就是它。上一篇说过 bipush 的 b 说的是立即数的宽度(8 位),不是栈上值的类型:压进栈的仍然是 int。这一篇在字节里看到了这个立即数:0a。

1000 更大,带符号的 8 位最多表示 127,bipush 装不下,addThousand 用的是 sipush ⬇️

text 复制代码
  int addThousand(int);
    descriptor: (I)I
    flags: (0x0000)
    Code:
      stack=2, locals=2, args_size=2
         0: iload_1
         1: sipush        1000
         4: iadd
         5: ireturn

方法体 6 个字节:1b 11 03 e8 60 ac。sipush 的 opcode 11 后面跟了两个操作数字节 03 和 e8,这两个字节怎么变成 1000?规范给了规则 ⬇️

If an operand is more than one byte in size, then it is stored in big-endian order - high-order byte first. For example, an unsigned 16-bit index into the local variables is stored as two unsigned bytes, byte1 and byte2, such that its value is (byte1 << 8) | byte2.

高字节在前:(0x03 << 8) | 0xE8 = 1000。多字节操作数一律按这个顺序排,这就是大端序,sipush 被取出时两个字节同时亮出来 ⬇️

hi、lo 两个格子的分工一目了然:03 是高字节,e8 是低字节,拼装发生在取操作数的那一步。

iinc:一条指令带两个操作数

第三篇说过 iinc 是算术指令里的例外:不经过操作数栈。现在可以看到它的字节形态 ⬇️

text 复制代码
  void inc(int);
    descriptor: (I)V
    flags: (0x0000)
    Code:
      stack=0, locals=2, args_size=2
         0: iinc          1, 1
         3: return

方法体 4 个字节:84 01 01 b1。iinc 的 opcode 84 后面跟了两个操作数字节,javap 显示成 1, 1------第一个 1 是局部变量表的 slot 序号,第二个 1 是要加的常数。i++ 被压成一条指令:从哪个 slot 加、加多少,全写在字节里,连栈都不用碰 ⬇️

字节流面板里 index 和 const 两个格子,就是 javap 里逗号两侧的两个 1 ⬇️

demo 把实参初值设为 1,右边的帧面板是这条指令的效果:slot 1 的值从 1 变成 2,操作数栈自始至终是空的------stack=0 在这里是有画面的。

100 和 1000000:操作数在常量池里

指令里能放的操作数有限:bipush 带 1 个字节,sipush 带 2 个。更大的数装不下,就得找个地方存------常量池。3.4 节(Accessing the Run-Time Constant Pool)开头说 ⬇️

Many numeric constants, as well as objects, fields, and methods, are accessed via the run-time constant pool of the current class. Object access is considered later (§3.8). Data of types int, long, float, and double, as well as references to instances of class String, are managed using the ldc , ldc_w , and ldc2_w instructions.

规范给了一个把五种常数一次看全的例子 ⬇️

java 复制代码
void useManyNumeric() {
    int i = 100;
    int j = 1000000;
    long l1 = 1;
    long l2 = 0xffffffff;
    double d = 2.2;
}

编译后用 javap -v 反汇编 ⬇️

text 复制代码
  void useManyNumeric();
    descriptor: ()V
    flags: (0x0000)
    Code:
      stack=2, locals=9, args_size=1
         0: bipush        100
         2: istore_1
         3: ldc           #7                  // int 1000000
         5: istore_2
         6: lconst_1
         7: lstore_3
         8: ldc2_w        #8                  // long -1l
        11: lstore        5
        13: ldc2_w        #10                 // double 2.2d
        16: dstore        7
        18: return

五行赋值,四种取常数的方式:

  • int i = 100:bipush 100,值装得进 1 个字节,直接写在指令里
  • int j = 1000000:ldc #7------1000000 超出 sipush 的 16 位范围,指令里只放了一个常量池索引 #7,值躺在池子里
  • long l1 = 1:lconst_1,小到连常量池都不用进
  • long l2 = 0xffffffff:ldc2_w #8。javap 显示的是 long -1l------0xffffffff 作为 int 字面量是 -1,赋给 long 后仍是 -1,常量池里存的就是 -1L
  • double d = 2.2:ldc2_w #10

这个类用到的三项常量池条目 ⬇️

text 复制代码
   #7 = Integer            1000000
   #8 = Long               -1l
  #10 = Double             2.2d

注意 #9 被跳过了:Long 和 Double 在常量池里各占两项,所以 #8 之后的下一个条目是 #10。这里的 #7 / #8 / #10 是本文这个类的编号;规范 3.4 的示例里写作 #1 / #6 / #8,编号随 class 变,含义不变。

ldc 的字节结构和 bipush 一样:opcode 12 加一个操作数字节 07,只是这次操作数的含义不是值,而是"常量池第 7 项" ⬇️

demo 里的 million() 编译成同样的两条指令,取出索引后右边常量池面板把 #7 高亮出来 ⬇️

第三篇的问题到这儿就兑现了:100 和 1000000 走不同的指令,不是类型不同(都是 int),而是宽度不同------立即数装得下的进指令(bipush 1 字节、sipush 2 字节),装不下的进常量池。常量池条目的编号由具体 class 决定,换个类就会换号;稳定的只有它占几个字节。

ldc、ldc_w、ldc2_w 的分工

三者的区别只有两处,规范写得很清楚 ⬇️

The ldc and ldc_w instructions are used to access values in the run-time constant pool (including instances of class String) of types other than double and long. The ldc_w instruction is used in place of ldc only when there is a large number of run-time constant pool items and a larger index is needed to access an item. The ldc2_w instruction is used to access all values of types double and long; there is no non-wide variant.

两个维度各管一件事:

  • 值的类型 :double 和 long 占 2 个 slot(第三篇讲过的宽度),只能走 ldc2_w;其余类型走 ldc 或 ldc_w。
  • 索引的宽度 :ldc 的索引是 1 个字节,只能寻址 1~255(0 不是合法的常量池索引);索引超过 255 时才换 ldc_w,操作数变成 2 字节。

引用里还有一句值得留意:ldc2_w 没有非宽变体------不存在 1 字节索引的 ldc2。它的 2 说的是值占两个 slot,w 说的是索引也必然是 2 字节;而 ldc_w 的 w 只改索引宽度,栈上的值仍是 1 个 slot 的 int、float 或引用。两个"宽度"别混。

本文的 demo 只画了 ldc:ldc_w 除了索引占 2 字节,取操作数、查常量池、压栈的步骤完全一样;ldc2_w 也只是多一个"值占两个 slot"的维度,画面上没有新东西,就不再单独占一节。

配套 demo

配套的 InstructionDemo.java 是一个 Swing 窗口,用下拉框在五个方法之间切换------add(零个操作数)、addTen(bipush)、addThousand(sipush)、inc(iinc)、million(ldc)------左边是源码和解码后的指令,右上方是字节流面板,右下方是局部变量表、操作数栈和常量池。demo 只覆盖这五种形态;ldc_w / ldc2_w 的差异只在索引和值的宽度上,不再单独做示例。下载后运行(需 JDK 16+,用到了 record;本文用 JDK 21)⬇️

bash 复制代码
javac InstructionDemo.java
java InstructionDemo

窗口上方切换方法,Step ▶ 单步执行一条指令,Run 自动播放剩下的指令,Reset 回到 pc = 0。

字节流面板的颜色约定:蓝色格是本步取出的 opcode,琥珀色边框是本步取出的操作数字节,浅蓝色是已经取出的字节;pc 箭头指向下一个要取的字节。常量池面板是真实常量池的摘录------一个类的常量池里还有类名、方法名等大量条目,图里用"略"标出。

字节和常量池索引都取自真实 class 文件:各方法的指令清单和 #7 都与 javap -v 的输出一致。demo 本身没有解析 class 文件,而是把验证过的字节预先放进了模拟的解释器循环------这个循环就是 2.11 节开头那段 do-while。

数字对照

数字 含义 出处
1b 1c 60 ac 四条单字节指令 add(int, int) 的全部字节
1b 10 0a 60 ac bipush 带 1 字节立即数 addTen(int) 的全部字节
03 e8 16 位立即数,大端存放 sipush 1000,`(0x03 << 8)
84 01 01 b1 两个操作数:slot 与增量 inc(int) 的全部字节
12 07 ac ldc 带 1 字节常量池索引 million() 的全部字节,#7 指向 Integer 1000000

留一道动手题:给 ShowBytes 加一个 int half() { return 200; } 再 javap 一下------bipush 还是 sipush?为什么?

下面是参考答案,建议先自己动手试试再往下看。

text 复制代码
  int half();
    descriptor: ()I
    flags: (0x0000)
    Code:
      stack=1, locals=1, args_size=1
         0: sipush        200
         3: ireturn

bipush 的操作数是带符号的 8 位,最大表示到 127,200 装不下,只能用 16 位的 sipush。第三篇的动手题是类型决定指令(byte 参数走 int 的指令),这一题是宽度决定指令------两个决定因素,这一篇和上一篇正好各看了一个。

小结

  1. 一条指令 = 1 字节 opcode + 零或多个操作数:解释器循环就是"取 opcode、取操作数、执行",pc 顺着字节流往前走。
  2. 操作数有三个来源 :不带操作数(iload_1、iadd);立即数跟在 opcode 后面(bipush、sipush、iinc);常量池索引(ldc、ldc_w、ldc2_w)。
  3. 多字节操作数一律大端 :高字节在前,(byte1 << 8) | byte2。
  4. 100 走 bipush,1000000 走 ldc :立即数装得下的值进指令,装不下的进常量池;long/double 只能走 ldc2_w。
  5. 索引超过 255 用 ldc_w:操作数从 1 字节变 2 字节,仅此而已。

下一篇看控制流:if 和 switch 编译成什么指令,tableswitch 和 lookupswitch 怎么选------2.11 节留的"唯一对齐例外"这个伏笔,到时候也该还了。

参考资料

相关推荐
最强小杰34 分钟前
某 OpenAI 兼容网关上的 `kimi-k3.1-pro`:Cline、Zed 接入与 SSE 排错示例
java·服务器·网络·ai
Flynn Liang1 小时前
流量治理不是限流那么简单:I/O 密集型 Java 服务的 6 层防线
java·微服务·高并发·限流·熔断·系统稳定性·resilience4j
学长毕设1 小时前
基于SpringBoot智慧养老服务平台设计与实现-附源码
java·spring boot·后端
曹牧2 小时前
Java:“刷新雪崩”
java·开发语言
秋天的怀念_David2 小时前
算法一千零一夜 · 第三十三夜 · 跳表
java·程序人生·算法
Forget the Dream3 小时前
Spring AI 2.0 系列(二):第一个 ChatClient——从注入到一次完整调用
java·人工智能·spring boot·ai·springai
黑十5 小时前
FDE 怎么快速搭一个可演示页面?最小前端方案
java·大数据·前端·数据库·人工智能
神明不懂浪漫5 小时前
【第八章】多线程(一)
java·开发语言·经验分享·笔记
用户54817845909506 小时前
Java 与 Python 在大模型与智能体领域的选型
java·python