这是 addTen 的方法体——四条指令,五个字节。bipush 的偏移是 1,下一条 iadd 却从 3 开始。多出来的那个字节装了什么?
前三篇我们借助 javap 查看了字节码指令:iload_1、iadd、iinc……
但 class 文件里存的是字节,一条指令到底占几个字节?操作数保存在哪里?第三篇文章结尾还留了两个问题——ldc、ldc_w、ldc2_w 分别取什么,100 和 1000000 为什么走不同的指令——本文把指令拆到字节这一层,这几个问题一起回答。
下文不带
0x前缀的字节串均为十六进制;javap的偏移列就是字节数组的下标。
规范 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
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 个字节,是规范在紧凑与性能之间做的取舍:8 位最多 256 个编码,指令集规模因此被限死,换来的是很多指令一个字节就是完整的一条;代价是超过一个字节的立即数得在运行时从字节拼出来(2.11 节)。
2.11 节紧接着还规定:字节码只按单字节对齐,唯一的例外是 tableswitch 和 lookupswitch——它们的部分操作数要填充到 4 字节边界。这个例外为什么存在,留到讲控制流的那一篇再说。
五个方法,五种操作数形态
我们用一组方法作为观察对象,这些方法覆盖了常见的操作数形态 ⬇️
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` | `iadd` | `1b 1c 60 ac` | 无操作数 |
| `addTen` | `bipush 10` | `1b 10 0a 60 ac` | 1 字节立即数 |
| `addThousand` | `sipush 1000` | `1b 11 03 e8 60 ac` | 2 字节立即数(大端) |
| `inc` | `iinc 1, 1` | `84 01 01 b1` | 2 个操作数:slot 序号 + 增量 |
| `million` | `ldc #7` | `12 07 ac` | 1 字节常量池索引 |
零个操作数:iadd 指令
先看 add 方法 ⬇️
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 个字节。add 的方法体就是 1b 1c 60 ac 这四个字节 ⬇️
四条指令都没有操作数,opcode 本身就是完整的指令。
这里有个容易一眼滑过的事实:iload_1 里的 1 不是操作数字节,而是编在 opcode 里——0x1B 这个字节已经同时表达了"取 int"和"取 slot 1"。JVM 为最常用的 slot 0~3 各准备了一条单字节短格式(iload_0 ~ iload_3);超过 3 就得换成 iload 加一个操作数字节,变成 2 字节。同一个动作、两种字节长度,正是"一字节 opcode"这个取舍的直接后果——后面 useManyNumeric 里会同时出现 lstore_3 和 lstore 5,正好拿来对照。
javap 命令不显示这些字节,配套 demo 的字节流面板补上了这一层 ⬇️
每个格子是一个字节:左上是偏移,中间是十六进制,下面是这个字节在指令里扮演的角色。此刻 pc = 0,四条指令的边界用括线画了出来——javap 偏移列里的 0、1、2、3,和图里的指令分组一一对应。
1 字节立即数:bipush 指令
addTen 方法里出现了一个带操作数的指令 ⬇️
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。
2 字节立即数:sipush 指令
1000 更大,带符号的 8 位最多表示 127,bipush 装不下,addThousand 用的是 sipush ⬇️
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 取出的 16 位按带符号数解释,再符号扩展成 int 压栈——和 bipush 的处理方式一样,只是宽度翻倍,所以范围是 -32768~32767。sipush 被取出时两个字节同时亮出来 ⬇️
hi、lo 两个格子的分工一目了然:03 是高字节,e8 是低字节,拼装发生在取操作数的那一步。
两个操作数:iinc 指令
第三篇说过 iinc 是算术指令里的例外:不经过操作数栈。现在可以看到它的字节形态 ⬇️
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 序号(u1),第二个 1 是要加的常数。留意后者的类型:它是带符号 1 字节,范围 -128~127,和 bipush 的立即数同一种宽度。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, anddouble, as well as references to instances of classString, are managed using the ldc, ldc_w, and ldc2_w instructions.
下面这个例子来自规范 3.4,不在 demo 的 ShowBytes 里;它把五种常数一次看全 ⬇️
void useManyNumeric() {
int i = 100;
int j = 1000000;
long l1 = 1;
long l2 = 0xffffffff;
double d = 2.2;
}
编译后用 javap -v 反汇编 ⬇️
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
先把开头埋的伏笔收一下:偏移 7 的 lstore_3 只有 1 字节,slot 号 3 已经编进 opcode;偏移 11 的 lstore 5 占 2 字节,slot 号 5 单独占一个操作数字节,所以下一条 ldc2_w 的偏移是 13 而不是 12。同一个动作、两种字节长度——这就是前面说的"一字节 opcode"取舍在真实代码里的样子。
五行赋值,四种取常数的方式:
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,常量池里存的就是-1Ldouble d = 2.2:ldc2_w #10
这个类用到的三项常量池条目 ⬇️
#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() 也是以 ldc #7 开头,后跟 ireturn(字节 12 07 ac);取出索引后右边常量池面板把 #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 thandoubleandlong. 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 typesdoubleandlong; 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”的维度,画面上没有新东西,就不再单独占一节。
字节层面三者差在哪,补一眼就够:
| 指令 | opcode | 操作数字节 | 含义 |
|---|---|---|---|
| `ldc #7` | `12` | `07`(1 字节) | 常量池第 7 项,值占 1 个 slot |
| `ldc_w #300` | `13` | `01 2c`(2 字节) | 常量池第 300 项,值仍占 1 个 slot |
| `ldc2_w #8` | `14` | `00 08`(2 字节) | 常量池第 8 项,值是 `long`/`double`,占 2 个 slot |
01 2c 就是 300 的大端表示。想让 javap 真的吐出 ldc_w,得往类里塞 256 个以上的常量池条目(比如几百个不同的字符串);想让 ldc2_w 出现,写一句 long x = 1L << 40; 就够了——值超出 int 范围,只能进常量池。
配套 demo
配套的 InstructionDemo.java 是一个 Swing 窗口,用下拉框在五个方法之间切换——add(零个操作数)、addTen(bipush)、addThousand(sipush)、inc(iinc)、million(ldc)——左边是源码和解码后的指令,右上方是字节流面板,右下方是局部变量表、操作数栈和常量池。demo 只覆盖这五种形态;ldc_w / ldc2_w 的差异只在索引和值的宽度上,不再单独做示例。下载后运行(需 JDK 16+,用到了 record;本文用 JDK 21)⬇️
javac InstructionDemo.java
java InstructionDemo
窗口上方切换方法,Step ▶ 单步执行一条指令,Run 自动播放剩下的指令,Reset 回到 pc = 0。
字节流面板的颜色约定:蓝色格是本步取出的 opcode,琥珀色边框是本步取出的操作数字节,浅蓝色是已经取出的字节;pc 箭头指向下一个要取的字节。常量池面板是真实常量池的摘录——一个类的常量池里还有类名、方法名等大量条目,图里用“略”标出。
字节和常量池索引都取自真实 class 文件:各方法的指令清单和 #7 都与 javap -v 的输出一致。demo 本身没有解析 class 文件,而是把验证过的字节预先放进了模拟的解释器循环——这个循环就是 2.11 节开头那段 do-while。
自己核对这些字节
文中的字节串不是手算的,读者也能复现。把上面的 ShowBytes 存成 ShowBytes.java——方法保持包可见,别加 public,否则清单里的 flags 会从 0x0000 变成 0x0001,和文中对不上。然后:
javac -g ShowBytes.java
javap -p -c -v ShowBytes
-p 不能省——ShowBytes 的方法都是包级可见,javap 默认只列 public / protected 成员。这条命令给出助记符和偏移(如 1: bipush 10、3: iadd),但不打印十六进制字节。想看原始字节,再用 xxd(macOS / Linux)或 hexdump -C:
xxd ShowBytes.class
定位方法:class 文件里每个方法的 Code 属性依次记录 max_stack、max_locals、code_length,紧跟 code_length 之后的 code_length 个字节就是方法体;javap 输出里的偏移 0、1、3 正是这个字节数组的下标。拿 addTen 来说,在 xxd 输出里找到 1b 10 0a 60 ac,对照 javap 的 1: bipush 10,就能看到"opcode + 操作数"怎么落在一串字节里。
更省事的路子是用 ASM 的 ClassReader 直接读出 code 数组再逐个解码——本文没走这条路,但验证字节码时它最常用。
数字对照
| 数字 | 含义 | 出处 |
|---|---|---|
| `1b 1c 60 ac` | 四条单字节指令 | `add(int, int)` 的全部字节 |
| `1b 10 0a 60 ac` | `bipush` 带 1 字节立即数 | `addTen(int)` 的全部字节 |
| `03 e8` | 16 位立即数,大端存放 | `sipush 1000`,`(0x03 << 8) | 0xE8 = 1000` |
| `84 01 01 b1` | 两个操作数:slot 与增量 | `inc(int)` 的全部字节 |
| `12 07 ac` | `ldc` 带 1 字节常量池索引 | `million()` 的全部字节,`#7` 指向 `Integer 1000000` |
动手题:200 走 bipush 还是 sipush
给 ShowBytes 加一个 int half() { return 200; } 再 javap 一下——bipush 还是 sipush?为什么?
下面是参考答案,建议先自己动手试试再往下看。
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。顺带追一个边界:128 走 sipush,-128 却仍走 bipush——判断标准是"能不能塞进带符号 1 字节",不是绝对值大小。前面 iinc 的常数也是同样的 1 字节边界,把 i++ 换成 i += 200,iinc 就装不下,得拆成 iload / sipush / iadd / istore 四步。
第三篇的动手题是类型决定指令(byte 参数走 int 的指令),这一题是宽度决定指令——两个决定因素,这一篇和上一篇正好各看了一个。
小结
- 一条指令 = 1 字节 opcode + 零或多个操作数:解释器循环就是“取 opcode、取操作数、执行”,pc 顺着字节流往前走。
- 操作数的字节内容分三类:无操作数——信息已编进 opcode(
iload_1、iadd);立即数——值本身跟在 opcode 后面(bipush、sipush、iinc的常数);索引——指向别处(iinc的局部变量 slot、常量池索引ldc/ldc_w/ldc2_w,以及分支指令的偏移量)。 - 多字节操作数一律大端:高字节在前,
(byte1 << 8) | byte2。 100走bipush,1000000走ldc:立即数装得下的值进指令,装不下的进常量池;long/double只能走ldc2_w。- 索引超过 255 用
ldc_w:操作数从 1 字节变 2 字节,仅此而已。
下一篇看控制流:if 和 switch 编译成什么指令,tableswitch 和 lookupswitch 怎么选——2.11 节留的“唯一对齐例外”这个伏笔,到时候也该还了。想先看 tableswitch 的填充字节,还是 if 的条件取反?评论区点个题。
把javap看不到的字节层补齐,用偏移与十六进制讲清opcode与操作数边界,适合已会读字节码、想弄懂指令编码与宽窄选择的开发者。