开发者社区> 寒泉子> 正文
阿里云
为了无法计算的价值
打开APP
阿里云APP内打开

假笨说-从X86指令深扒JVM的位移操作

简介: 概述 之所以会写这个,主要是因为最近做的一个项目碰到了一个移位的问题,因为位移操作溢出导致结果不准确,本来可以点到为止,问题也能很快解决,但是不痛不痒的感觉着实让人不爽,于是深扒了下个中细节,直到看到Intel的指令规约才算释然,希望这篇文章能引起大家共鸣。 本文或许看起来会比较枯燥,不过其实认
+关注继续查看

概述

之所以会写这个,主要是因为最近做的一个项目碰到了一个移位的问题,因为位移操作溢出导致结果不准确,本来可以点到为止,问题也能很快解决,但是不痛不痒的感觉着实让人不爽,于是深扒了下个中细节,直到看到Intel的指令规约才算释然,希望这篇文章能引起大家共鸣。

本文或许看起来会比较枯燥,不过其实认真看挺有意思的,如果实在看不下去,告诉你一个极简路径,先看下下面的Demo,然后直接跳到后面的小结,如果懂了,别忘记顺便点个赞,请叫我雷锋,哈哈。

Demo

还是从一个简单的例子说起

public class ShiftTest {
    public static void main(String args[]) {
        System.out.println(doShiftL(35));
    }

    public static long doShiftL(int shift) {
        return 4 << shift;
    }
}

大家可以尝试做几个改变,看看结果怎样

  • 4 << shift改成4L << shift
  • 将35改成291,PS:提示一下291=35+256*1

如果上面的各种结果你都能解释,那说明你对位移操作还是有一定了解的,不过本文主要从JVM到Intel X86_64指令角度来分析这个问题,或许也值得一看

JVM里44L的区别

要知道区别,我们看doShiftL方法通过javac编译出来的指令有什么不一样

4 << shift的字节码

 0: iconst_4
 1: iload_0
 2: ishl

4L << shift的字节码

 0: ldc2_w        #34                 // long 4l
 3: iload_0
 4: lshl

针对44L的区别,我们看到了两条不同的指令,分别是iconst_4ldc2_w,其实如果我们将4改成其他的值,可能会有不一样的指令出现

  • -1<= x <=5: iconst_x
  • -128<= x <-1 || 5< x <=127bipush
  • -32768 <= x < -128 || 127 < x <= 32767sipush
  • -32768 > x || x > 32767ldc

不过这些都不是我们今天的重点,不想细说了,就以iconst_4为例来简单介绍下

iconst_4

先看iconst_4的大概汇编指令如下

  0x00007fcb529b0b00: push   %rax
  0x00007fcb529b0b01: jmpq   0x00007fcb529b0b30
  0x00007fcb529b0b06: sub    $0x8,%rsp
  0x00007fcb529b0b0a: movss  %xmm0,(%rsp)
  0x00007fcb529b0b0f: jmpq   0x00007fcb529b0b30
  0x00007fcb529b0b14: sub    $0x10,%rsp
  0x00007fcb529b0b18: movsd  %xmm0,(%rsp)
  0x00007fcb529b0b1d: jmpq   0x00007fcb529b0b30
  0x00007fcb529b0b22: sub    $0x10,%rsp
  0x00007fcb529b0b26: mov    %rax,(%rsp)
  0x00007fcb529b0b2a: jmpq   0x00007fcb529b0b30
  0x00007fcb529b0b2f: push   %rax
  0x00007fcb529b0b30: mov    $0x4,%eax
  0x00007fcb529b0b35: movzbl 0x1(%r13),%ebx
  0x00007fcb529b0b3a: inc    %r13
  0x00007fcb529b0b3d: mov    $0x7fcb63dd5760,%r10
  0x00007fcb529b0b47: jmpq   *(%r10,%rbx,8)

重点看0x00007fcb529b0b30这条就是将0x4移到EAX寄存器里,这是一个32位的寄存器,需要注意的是这里并没有直接将4 push到操作数栈上,而是在下一条指令(也就是iload_0)执行的时候才预先push到栈上,后面看iload_0的汇编代码可知

ldc2_w

ldc2_w是将long或者double的常量值从常量池推到操作数栈顶,其大概汇编指令如下

  0x00007fcb529b1960: push   %rax
  0x00007fcb529b1961: jmpq   0x00007fcb529b1990
  0x00007fcb529b1966: sub    $0x8,%rsp
  0x00007fcb529b196a: movss  %xmm0,(%rsp)
  0x00007fcb529b196f: jmpq   0x00007fcb529b1990
  0x00007fcb529b1974: sub    $0x10,%rsp
  0x00007fcb529b1978: movsd  %xmm0,(%rsp)
  0x00007fcb529b197d: jmpq   0x00007fcb529b1990
  0x00007fcb529b1982: sub    $0x10,%rsp
  0x00007fcb529b1986: mov    %rax,(%rsp)
  0x00007fcb529b198a: jmpq   0x00007fcb529b1990
  0x00007fcb529b198f: push   %rax
  0x00007fcb529b1990: movzwl 0x1(%r13),%ebx
  0x00007fcb529b1995: bswap  %ebx
  0x00007fcb529b1997: shr    $0x10,%ebx
  0x00007fcb529b199a: mov    -0x18(%rbp),%rcx
  0x00007fcb529b199e: mov    0x10(%rcx),%rcx
  0x00007fcb529b19a2: mov    0x8(%rcx),%rcx
  0x00007fcb529b19a6: mov    0x10(%rcx),%rax
  0x00007fcb529b19aa: cmpb   $0x6,0x4(%rax,%rbx,1)
  0x00007fcb529b19af: jne    0x00007fcb529b19c2
  0x00007fcb529b19b1: movsd  0x60(%rcx,%rbx,8),%xmm0
  0x00007fcb529b19b7: sub    $0x10,%rsp
  0x00007fcb529b19bb: movsd  %xmm0,(%rsp)
  0x00007fcb529b19c0: jmp    0x00007fcb529b19cf
  0x00007fcb529b19c2: mov    0x60(%rcx,%rbx,8),%rax
  0x00007fcb529b19c7: sub    $0x10,%rsp
  0x00007fcb529b19cb: mov    %rax,(%rsp)
  0x00007fcb529b19cf: movzbl 0x3(%r13),%ebx
  0x00007fcb529b19d4: add    $0x3,%r13
  0x00007fcb529b19d8: mov    $0x7fcb63dd7f60,%r10
  0x00007fcb529b19e2: jmpq   *(%r10,%rbx,8)

重点看0x00007fcb529b1990这条开始,主要就是从常量池里取出相关的值,然后push到操作数栈上(看0x00007fcb529b19c2这行开始的接下来三行)

因此做一个小结:

  • iconst_4:将4存入到EAX寄存器,但是此时还并没有将4 push到操作数栈顶
  • ldc2_w:将后面跟着的值(其实也就会4),存到RAX寄存器,并且将其push到操作数栈顶

着重注意下上面两条指令使用的两个寄存器是不一样的,一个是EAX,一个是RAX,其中RAX是64位寄存器,而EAX是RAX寄存器的低32位,是一个32位寄存器

不过还没结束,对于iconst_4这种情况,什么时候将4 push到栈上呢,那接下来我们看看iload_0这条指令,因为不管是iconst_4还是ldc2_w,后面都跟了iload_0,所以还是一起来看看这条指令

iload_0

iload_0的汇编实现大致如下:

  0x00007fcb529b1ee0: push   %rax
  0x00007fcb529b1ee1: jmpq   0x00007fcb529b1f10
  0x00007fcb529b1ee6: sub    $0x8,%rsp
  0x00007fcb529b1eea: movss  %xmm0,(%rsp)
  0x00007fcb529b1eef: jmpq   0x00007fcb529b1f10
  0x00007fcb529b1ef4: sub    $0x10,%rsp
  0x00007fcb529b1ef8: movsd  %xmm0,(%rsp)
  0x00007fcb529b1efd: jmpq   0x00007fcb529b1f10
  0x00007fcb529b1f02: sub    $0x10,%rsp
  0x00007fcb529b1f06: mov    %rax,(%rsp)
  0x00007fcb529b1f0a: jmpq   0x00007fcb529b1f10
  0x00007fcb529b1f0f: push   %rax
  0x00007fcb529b1f10: mov    (%r14),%eax
  0x00007fcb529b1f13: movzbl 0x1(%r13),%ebx
  0x00007fcb529b1f18: inc    %r13
  0x00007fcb529b1f1b: mov    $0x7fcb63dd5760,%r10
  0x00007fcb529b1f25: jmpq   *(%r10,%rbx,8)

这条指令简单来说就是将方法的0号local槽里的数据存到EAX寄存器里,不过针对上一条指令是iconst_4,此时会先做一个push的动作,将RAX寄存器里的值push到操作数栈上,但是如果是ldc2_w指令的话,就不会做push了,因为这两条指令规定的执行完后的top of stack不一样,iconst_4要求栈顶是一个int,而ldc2_w没要求,尽管在实现里确实将值push到了栈顶

因此在执行完iload_0之后,都已经将4 push到操作数栈顶了,并且将第一个local槽,其实就是doShiftL函数的shift参数存到了EAX寄存器里,具体看上面的0x00007fcb529b1f0f位置的指令

JVM里的位移操作

从上面的字节码里我们看到,当我们位移的基数是4或者4L的时候,分别看到了两条不同的位移指令,分别是ishllshl,这两条指令一个是将int型的值左移一定位数,一个是将long型的值左移一定位数,那这两条指令分别有什么区别呢?

JVM里ishl指令实现

先看定义

def(Bytecodes::_ishl                , ____|____|____|____, itos, itos, iop2                , shl          );

对于ishl指令主要实现在iop2方法里,并且传递一个参数shl

void TemplateTable::iop2(Operation op) {
  transition(itos, itos);
  switch (op) {
  case add  :                    __ pop_i(rdx); __ addl (rax, rdx); break;
  case sub  : __ movl(rdx, rax); __ pop_i(rax); __ subl (rax, rdx); break;
  case mul  :                    __ pop_i(rdx); __ imull(rax, rdx); break;
  case _and :                    __ pop_i(rdx); __ andl (rax, rdx); break;
  case _or  :                    __ pop_i(rdx); __ orl  (rax, rdx); break;
  case _xor :                    __ pop_i(rdx); __ xorl (rax, rdx); break;
  case shl  : __ movl(rcx, rax); __ pop_i(rax); __ shll (rax);      break;
  case shr  : __ movl(rcx, rax); __ pop_i(rax); __ sarl (rax);      break;
  case ushr : __ movl(rcx, rax); __ pop_i(rax); __ shrl (rax);      break;
  default   : ShouldNotReachHere();
  }
}

因此主要实现其实就是

__ movl(rcx, rax); __ pop_i(rax); __ shll (rax); 

主要是将RAX寄存器里的值(其实就是doShiftL函数的shift参数)存入到RCX寄存器里(注意这里用的movl,其实是用的32位寄存器),然后将操作数栈顶的值(就是上述的4)存到RAX里,并做shll操作

void Assembler::shll(Register dst) {
  int encode = prefix_and_encode(dst->encoding());
  emit_byte(0xD3);
  emit_byte(0xE0 | encode);
}

那问题就来了,这里的0xD3,0xE0到底是什么鬼,不过我们能猜到是做的位移操作,那我们看看ishl完整的汇编代码

  0x00007fcb529b5920: mov    (%rsp),%eax
  0x00007fcb529b5923: add    $0x8,%rsp
  0x00007fcb529b5927: mov    %eax,%ecx
  0x00007fcb529b5929: mov    (%rsp),%eax
  0x00007fcb529b592c: add    $0x8,%rsp
  0x00007fcb529b5930: shl    %cl,%eax
  0x00007fcb529b5932: movzbl 0x1(%r13),%ebx
  0x00007fcb529b5937: inc    %r13
  0x00007fcb529b593a: mov    $0x7fcb63dd5760,%r10
  0x00007fcb529b5944: jmpq   *(%r10,%rbx,8)

上述的0x00007fcb529b5930其实就应该是上面的Assembler::shll的输出了,里面有CL寄存器(RCX寄存器的低32位是ECX,而ECX的低8位是CL,这个关系清楚了吧)和EAX寄存器,看到这指令其实可以解释了,CL寄存器因为是ECX寄存器的低8位,而我们从上面得知RCX里存的其实是要位移的位数,也就是上面Demo里的doShiftL函数的shift参数值,而EAX寄存器里的值是操作数栈顶的值,也就是4

那现在的问题是明明我们就传了一个RAX的寄存器给Assembler::shll,那怎么操作起CL寄存器来了,这其实就是我想写本文的根本原因,我想解释这个现象,还想知道0xD3,0xE0到底是什么鬼,于是找了intel指令手册,看到SHL指令这样的描述

register by CL           1101 001w : 11 100 reg

0xD3的二进制表示是1101 0011,和上面的1101 001w是匹配的,这个w应该是如果是寄存器寻址,那就是1吧

0xE0的二进制表示是1110 0000,和上面的11 100 reg是匹配的,也就是reg占3位,那问题是寄存器个数并不只有8个,因此超过8个的情况怎么表示呢,那来看看encode的过程

int Assembler::prefix_and_encode(int reg_enc, bool byteinst) {
  if (reg_enc >= 8) {
    prefix(REX_B);
    reg_enc -= 8;
  } else if (byteinst && reg_enc >= 4) {
    prefix(REX);
  }
  return reg_enc;
}

这里的关键其实就是prefix的值了,通过设置prefix来看是否使用了普通寄存器之外的寄存器,这个大家网上可以找找相关资料看看,是X86的扩展64位技术

另外从上面的规范里我们看到了CL寄存器,也就是shl命令本身就是和CL寄存器紧密结合实现的(其中一种寻址方式而已),另外将shel之后的结果存到EAX寄存器里,再次提醒下是32位的寄存器,而和下面说的lshl的最大区别就是其使用的其实是64位的RAX寄存器,因此两者表示的最大值显然不一样啦

JVM里lshl指令实现

先看定义

def(Bytecodes::_lshl                , ____|____|____|____, itos, ltos, lshl                ,  _           );

lshl指令主要实现在lshl方法里

void TemplateTable::lshl() {
  transition(itos, ltos);
  __ movl(rcx, rax);                             // get shift count
  __ pop_l(rax);                                 // get shift value
  __ shlq(rax);
}

而pop_l的实现如下,使用了movq,也就是移动栈上的双字(8byte=64位,用RAX寄存器存)到寄存器里,注意上面的ishl使用的是movl,是移动长字到寄存器里(即4byte=32位,正好用EAX寄存器存),

void InterpreterMacroAssembler::pop_l(Register r) {
  movq(r, Address(rsp, 0));
  addptr(rsp, 2 * Interpreter::stackElementSize);
}

lshl的汇编实现:

  0x00007fcb529b59a0: mov    (%rsp),%eax
  0x00007fcb529b59a3: add    $0x8,%rsp
  0x00007fcb529b59a7: mov    %eax,%ecx
  0x00007fcb529b59a9: mov    (%rsp),%rax
  0x00007fcb529b59ad: add    $0x10,%rsp
  0x00007fcb529b59b1: shl    %cl,%rax
  0x00007fcb529b59b4: movzbl 0x1(%r13),%ebx
  0x00007fcb529b59b9: inc    %r13
  0x00007fcb529b59bc: mov    $0x7fcb63dd5f60,%r10
  0x00007fcb529b59c6: jmpq   *(%r10,%rbx,8)

从这里也印证了确实用了RAX寄存器(请看0x00007fcb529b59b1)

总结

这篇文章因为涉及到太多的汇编指令,可能不少人看起来不是很明白,不过我觉得你可以多看几遍啦,看多了也许就看懂了,不过实现看不下去没关系,就看看小结吧

  • 当我们要位移的基数的类型是long的时候,其实是用64位的RAX寄存器来操作的,因此存的最大值(2^64-1)会更大,而如果基础是int的话,会用32位的EAX寄存器,因此能存的最大值(2^32-1)会小点,超过了阈值就会溢出
  • 使用了8位的CL寄存器来存要位移的位数,因此最大其实就是2^8-1=255啦,所以上述demo,如果我们将shift的参数从35改成291发现结果是一样的

欢迎各位关注本人微信公众号

qrcode_for_gh_936dbf859f26_430_1_

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

相关文章
vue再读17-系统指令v-bind
vue再读17-系统指令v-bind
5 0
Spark HadoopRdd partition的开始位置计算
- 源码分析Spark HadoopRDD是如何读取HDFS上的文件 - 分析HadoopRDD预分区的计算方式,非首个分区的开始位置计算
989 0
IL指令详细表
名称 说明 Add 将两个值相加并将结果推送到计算堆栈上。 Add.Ovf 将两个整数相加,执行溢出检查,并且将结果推送到计算堆栈上。 Add.Ovf.Un 将两个无符号整数值相加,执行溢出检查,并且将结果推送到计算堆栈上。
867 0
修改 suse 上的postfix 的日志路径
刚刚搭建的邮件服务器,没过多久硬盘就爆满了,不得已移动存储,包括日志。 移动存储灰常简单,查找 /etc/postfix/main.cf 中的 data_directory / base_directory ,设置到指定的目录即可。
637 0
+关注
寒泉子
目前主要从事JVM相关的工作,喜欢做一些技术研究性的工作,欢迎各位关注我的个人微信公众号&quot;你假笨&quot;,会时不时发点围绕JVM主题的文章
13
文章
0
问答
文章排行榜
最热
最新
相关电子书
更多
低代码开发师(初级)实战教程
立即下载
阿里巴巴DevOps 最佳实践手册
立即下载
冬季实战营第三期:MySQL数据库进阶实战
立即下载