美文网首页
JVM字节码

JVM字节码

作者: 折剑游侠 | 来源:发表于2022-07-01 17:42 被阅读0次

前言

Android开发讲道理更应该卷的是dex字节码,但实际上做应用开发时,插桩流程往往在class2dex的过程中,一些插桩框架最终操作的还是class字节码。Java世界JVM最终执行字节码指令,将class字节码解释成机器码执行;Android世界ART最终执行dex,将dex字节码解释成机器码执行。当然ART本身也做了好几次变更,现在基本上是解释、JIT、AOT混合的方式执行,见下图:


Android Runtime

简单的总结就是,apk安装时将dex加载进内存,首次执行方法时没有JIT编译缓存,解释执行,并将其缓存到JIT Cache同时将多次执行的热点方法配置到profile文件,机器在充电或其它闲置状态时执行dex2oat将profile文件配置的热点函数AOT编译成.oat文件,.oat本质上就是个elf文件了。后续方法执行时先找.oat,然后JIT Cache,都没有就解释执行。

dex字节码指令是基于寄存器的,class字节码是基于栈的,虚拟机层面的寄存器虽然也是内存模拟的,但是同样的操作基于寄存器的指令相比较于基于栈的class字节码是要少一些的,指令少就意味着对内存的访问次数少,执行效率自然就高。一般来说应用开发不太会去操作dex字节码,除非说做逆向,反编译dex,拿到smali文件,调试魔改重签名。虽然运行时也有dexmaker这种框架可以用Java api动态生成dex指令,但实际上还是在class字节码层面操作更多。

无论是class字节码还是dex字节码,都是编译器前端的产物IR,dex字节码相当于对class字节码再转换了一层,更适用于资源有限的移动平台机器。

dex文件格式也可以对应class文件格式来看。

JVM内存模型

BB了一堆,回到本文的重点。Java字节码是一组可以由JVM执行的高度优化的指令,它被记录在Class文件中,在虚拟机加载Class文件时执行。Class文件并不等于字节码,Class文件包含字节码,通俗来说字节码就是Class文件方法表(methods)中的Code属性。

先看看JDK8的内存结构,偷张图:


JDK8

当类被首次加载时,会在堆上创建类的Class对象其实也就是反射会用到的Class对象,同时Class文件中的信息被加载到JVM方法区中,字节码指令也会装配到方法区中,为方法的运行提供支持。

虚拟机栈是描述方法的内存模型,属于线程私有。虚拟机栈中方法调用时会创建栈帧,方法return返回时相应的会将栈帧出栈。栈帧可视为单个方法的内存模型,其又包括局部变量表、操作数栈、动态连接、方法出口。

  • 局部变量表用于储存方法参数和局部变量。
  • 操作数栈保存求值的中间结果、调用别的方法参数。
  • 动态连接指的是栈帧当前方法指向运行时常量池的一个引用,说白了也就是找到对应方法区的方法然后根据这个引用读取字节码。
  • 方法出口记录被调用的方法退出后回到上层方法的位置。

下面通过例子看一下字节码指令执行流程。

加载存储指令

根据我自己的学习方法,重点先关注局部变量表、操作数栈和三个字节码指令:

  1. 常量入栈指令
    将一个常量加载到操作数栈 :bipush、sipush、ldc、ldc_w、ldc2_w、aconst_null、iconst_m1、iconst_<i>、lconst_<l>、fconst_<f>、dconst_<d>
  2. 局部变量压栈指令
    xload、xload_<n>(其中x为i、l、f、d、a,而n为0~3)
  3. 出栈装入局部变量表指令
    将一个数值从操作数栈存储到局部变量表:xstore、xstore_<n>其中x为i、l、f、d、a,而n为0~3);xastore(其中x为i、l、f、d、a、b、c、s),局部变量表可以看做一个数组,对于非静态方法索引为0的位置默认为this指针。
说起来很抽象,下面看例子🌰🌰🌰
    public void add() {
        int a = 3;
        int b = 6;
        int c = a + b;
    }

对应字节码,逐行注释。这里用asm插件查看字节码,除了大小写之外基本没啥区别。

  public add()V
    ICONST_3    //常量3入栈
    ISTORE 1    //常量3出栈存入局部变量表下表为1的位置
    BIPUSH 6    //常量6入栈
    ISTORE 2    //常量6出栈存入局部变量表下表为2的位置
    ILOAD 1     //常量3入栈,load指令将局部变量复制一份到操作数栈
    ILOAD 2     //常量6入栈
    IADD        //3,6出栈执行加法,将结果9入栈
    ISTORE 3    //9出栈存入局部变量表下标为3的位置
    RETURN
    MAXSTACK = 2
    MAXLOCALS = 4

这里有个新的指令iadd表示操作数栈栈顶两个int类型数据出栈,执行加法运算将相加的结果入栈。与之相似,加减乘除等算数指令都一样,其实完全没有必要去背这些字节码指令,弄懂了同一类指令的执行流程就够了,遇到不记得的指令对应去查找就好了。

正好借这个简单的例子看一下dex字节码,这里借助AS java2smali插件:

# virtual methods
.method public add()V
    .registers 4

    .prologue
    .line 5
    const/4 v0, 0x3

    .line 6
    .local v0, "a":I
    const/4 v1, 0x6

    .line 7
    .local v1, "b":I
    add-int v2, v0, v1

    .line 8
    .local v2, "c":I
    return-void
.end method

其实相对来说更接近汇编的dex字节码反而更好懂,毕竟计算没有入栈出栈的过程直接add-int v2, v0, v1,去掉行号使用的指令确实也更少。事实上学会了阅读class字节码,dex字节码肯定也不在话下。本文后面就不再关注dex字节码了,有兴趣的小伙伴可以对照指令集学习dalvik-bytecode

继续看🌰🌰🌰1
    public void add(){
        int i = 3;
        i = i++;
    }

对应字节码

  public add()V
    ICONST_3    //将常量3压入操作数栈
    ISTORE 1    //操作数栈出栈,存入局部变量表下标为1的位置
    ILOAD 1     //局部变量表下标为1的变量加载到操作数栈
    IINC 1 1    //4--->自增指令,IINC后面两个1,第一个是局部变量表位置,第二个是增加多少。
    ISTORE 1    //3--->操作数栈出栈,存入局部变量表下标为1的位置
    RETURN
    MAXSTACK = 1
    MAXLOCALS = 2

很清晰了啊,i++自增之后会被操作数栈原本的值重新覆盖,所以还是3。

经典八股🌰🌰🌰2
    public void add() {
        int i = 3;
        i = i++ + ++i;
    }

字节码,重点关注操作数栈和局部变量表变化,先忽略局部变量表下标为0的位置保存了this。

  public add()V
    ICONST_3    //栈3,表null
    ISTORE 1    //栈null,表3
    ILOAD 1     //栈3,表3
    IINC 1 1    //栈3,表4
    IINC 1 1    //栈3,表5
    ILOAD 1     //栈3、5,表5
    IADD        //栈8,表5
    ISTORE 1    //栈null,表8
    RETURN
    MAXSTACK = 2
    MAXLOCALS = 2
}

看到这里,什么i = i++、i = ++i、i = i++ + ++i、i = ++i + i++还不是手到擒来,站在字节码的角度看这些迷惑操作可以说是降维打击了。

继续强化一波,经典八股🌰🌰🌰3
    public void add() {
        int i = 3;
        i = ++i + i++;
    }

对应字节码

  public add()V
    ICONST_3  //栈3,表null
    ISTORE 1  //栈null,表3
    IINC 1 1  //栈null,表4
    ILOAD 1   //栈4,表4
    ILOAD 1   //栈4、4,表4
    IINC 1 1  //栈4、4,表5
    IADD      //栈8,表5
    ISTORE 1  //栈null,表8
    RETURN
    MAXSTACK = 2
    MAXLOCALS = 2
}

过程有点不一样,但结果还是8,到这肯定能看懂局部变量的声明和一些算数运算了。那有的同学就会问,你这是只是局部变量啊,那全局变量、静态变量执行流程也一样吗?别慌,拉出来溜溜看。

全局变量🌰🌰🌰4
public class Num {
    int i;

    public void add() {
        i = 3;
        i = ++i + i++;
    }
}

说实话,下面这段我建议大家自己跟一遍,没看字节码之前无法想象这么点代码居然会生成这么多指令。

  public add()V
    ALOAD 0   //0是this,局部变量表的this加载到操作数栈
    ICONST_3  //常量3入栈
    //赋值给全局变量i,其实就等同于this.i = 3
    PUTFIELD com/chenxuan/code/Num.i : I
    ALOAD 0   //this入栈
    ALOAD 0   //this入栈
    DUP       //复制栈顶this,此时栈3个this
    //this出栈,获取全局变量i入栈
    GETFIELD com/chenxuan/code/Num.i : I
    ICONST_1  //常量1入栈,此时栈this、this、i、1
    IADD      //1,i出栈执行加法,加法运算结果4入栈,此时栈this、this、4
    DUP_X1    //复制栈顶4,插入下标1,此时栈this、4、this、4
    //全局变量赋值,this.i = 4,此时栈this、4
    PUTFIELD com/chenxuan/code/Num.i : I
    ALOAD 0   //this入栈
    DUP       //复制this,此时栈this、4、this、this
    //全局变量i入栈,此时栈this、4、this、i,需注意i的值已经是4了
    GETFIELD com/chenxuan/code/Num.i : I
    DUP_X1    //复制栈顶i插入下标1,此时栈this、i、4、this、i
    ICONST_1  //常量1入栈,此时栈this、i、4、this、i、1
    IADD      //加法运算,此时栈this、i、4、this、5
    //this.i = 5,此时栈this、i、4,需注意栈内的i还是4
    PUTFIELD com/chenxuan/code/Num.i : I
    IADD      //加法运算,此时栈this、8
    //this.i = 8,操作数栈空了
    PUTFIELD com/chenxuan/code/Num.i : I
    RETURN
    //栈的最大深度,对应前面this、i、4、this、i、1
    MAXSTACK = 6
    MAXLOCALS = 1

GETFIELD、PUTFIELD很好理解,全局变量取值赋值;DUP、DUP_X1详见下图:

dup & pop

上述全局变量get、put都是通过this进行调用,而this默认保存在局部变量表的第零项。

方法调用🌰🌰🌰5
public class Num {
    public void a() {
        b();
    }

    public void b() {

    }
}

看下字节码,方法内调用原类方法也是通过this,只不过这个this编译器帮忙生成了。

  public a()V
    ALOAD 0  //this
    INVOKEVIRTUAL com/chenxuan/code/Num.b ()V
    RETURN
    MAXSTACK = 1
    MAXLOCALS = 1

  public b()V
    RETURN
    MAXSTACK = 0
    MAXLOCALS = 1
方法调用指令
  1. invokevirtual
    用于调用对象的实例方法,支持多态。
  2. invokeinterface
    用于调用接口方法,运行时找到实现类的接口方法进行调用。
  3. invokespecial
    构造方法,私有方法,父类方法。
  4. invokestatic
    静态方法或者说是类方法。
  5. invokedynamic
    Java8 lambda使用,在运行时动态解析出调用点限定符所引用的方法,并执行该方法。

🌰🌰🌰5中this.b()就是对象实例方法了,所以调用指令为invokevirtualinvokevirtual、invokeinterface调用的方法都有可能会被重写,其实也就是多态,子类方法表首先会继承父类的方法,子类重写父类方法时,在方法表中用自己的实现替代父类方法。调用这些方法时,先找实例类,然后查找方法表中对应的方法进行调用。invokespecial、invokestatic调用的方法都是静态绑定的,不会被重写。

android平台的lambda有一个脱糖的过程,这也是插桩的老生常谈了,简单来说就是将invokedynamic的实现改为了匿名内部类的方式。

对象创建指令🌰🌰🌰6
public class Num {

    public void a() {
        Inner inner = new Inner();
    }

    static class Inner {

    }
}

字节码

  public a()V
    //堆上创建对象实例,引用入栈
    NEW com/chenxuan/code/Num$Inner
    DUP       //复制引用到栈顶
    //调用构造方法,引用出栈
    INVOKESPECIAL com/chenxuan/code/Num$Inner.<init> ()V
    ASTORE 1  //引用出栈,存入局部变量表
    RETURN
    MAXSTACK = 2
    MAXLOCALS = 2

对象创建的过程:先在堆上创建实例,对象引用push到操作数栈;dup复制一份引用,用来调用对象的构造方法;最后将剩余的引用存入局部变量,注意位置,0是当前对象this。

类型检查指令🌰🌰🌰7
    public void a(View view) {
        if (view instanceof TextView) {
            ((TextView) view).setText("TextView");
        }
    }

字节码

  public a(Landroid/view/View;)V
    ALOAD 1
    INSTANCEOF android/widget/TextView
    IFEQ L0
    ALOAD 1
    CHECKCAST android/widget/TextView
    LDC "TextView"
    INVOKEVIRTUAL android/widget/TextView.setText (Ljava/lang/CharSequence;)V
   L0
    RETURN
    MAXSTACK = 2
    MAXLOCALS = 2

对应指令就是INSTANCEOF、CHECKCAST,比较好理解,此处条件指令IFEQ不满足条件跳转L0,方法return返回。思考一下kotlin的智能转换,看一下kotlin的字节码,为啥不需要在代码中显示as向下转型。

🌰🌰🌰8
    fun text(view: View) {
        if (view is TextView) {
            view.text = "TextView"
            view.textSize = 16f
        }
    }

字节码,很容易想到编译器帮忙加了CHECKCAST

  public final text(Landroid/view/View;)V
    // annotable parameter count: 1 (invisible)
    @Lorg/jetbrains/annotations/NotNull;() // invisible, parameter 0
    ALOAD 1
    LDC "view"
    INVOKESTATIC kotlin/jvm/internal/Intrinsics.checkNotNullParameter (Ljava/lang/Object;Ljava/lang/String;)V
    ALOAD 1
    INSTANCEOF android/widget/TextView
    IFEQ L0
    ALOAD 1
    CHECKCAST android/widget/TextView
    LDC "TextView"
    CHECKCAST java/lang/CharSequence
    INVOKEVIRTUAL android/widget/TextView.setText (Ljava/lang/CharSequence;)V
    ALOAD 1
    CHECKCAST android/widget/TextView
    LDC 16.0
    INVOKEVIRTUAL android/widget/TextView.setTextSize (F)V
   L0
    RETURN
    MAXSTACK = 2
    MAXLOCALS = 2

有个比较神奇的ab值交换,这个说实话,反编译成Java也看不明白。

🌰🌰🌰9
    public fun ab() {
        var a = 3;
        var b = 4;
        a = b.also {
            b = a
        }
    }

字节码

  public final ab()V
    ICONST_0
    ISTORE 1
    ICONST_3
    ISTORE 1
    ICONST_0
    ISTORE 2
    ICONST_4
    ISTORE 2
    ILOAD 2
    ISTORE 3
    ILOAD 3
    ISTORE 4
    ICONST_0
    ISTORE 5
    ILOAD 1
    ISTORE 2
    NOP
    ILOAD 3
    ISTORE 1
    RETURN
    MAXSTACK = 1
    MAXLOCALS = 6
}

MAXLOCALS为6,里面一堆操作,最终局部变量表1的值变成了4,2的值变成了3完成交换。多出的三个局部变量想来是lambda内部ab的拷贝,还有一个就是lambda内部it指向的变量。

总结

说实话,八股归八股,这些i++的例子抛开恶心不谈,确实也让我有所收获,只能说记忆深刻。卷到这里,再回过头去看kotlin的编译产物、ASM插桩等,应该也是得心应手了。当然,最重要的是,技术对线不再挂机,大佬们在高谈阔论的时候,我也可以插个嘴嘴=。=

那实用主义的同学可能就会说了,你卷这些有个鸡儿用,对咱们的项目有一点帮助吗?别急,看下boosterByteX这么多ASM处理对项目的优化是实实在在的,总归要知其然知其所以然吧,总不能引入一下后续修改都无从下手吧。那booster、ByteX没有的一些功能,项目中的一些痛点自己下来也能撸了,还不是美滋滋。

相关链接:
jit-compiler
dalvik-bytecode
JVM字节码指令集
dex-format
class-format

相关文章

  • JVM知识精粹

    1.jvm执行字节码文件 流程:jvm通过类加载器加载字节码文件----字节码校验器---翻译字节码(解释执行,反...

  • JVM

    JVM 基础-类字节码详解 多语言编译为字节码在 JVM 运行 Java 字节码文件-- Class文件的结构属性...

  • Java并发机制的底层原理

    Java程序执行:Java代码→Java字节码→字节码被类加载器加载到JVM里,JVM执行字节码→转化为汇编指令在...

  • Java并发机制的底层实现原理

        Java代码在编译后会变成Java字节码,字节码被类加载器加载到JVM里,JVM执行字节码,最终需要转化为...

  • 并发 - Java并发机制的底层实现原理

    一、概述 Java代码在编译后会变成Java字节码,字节码被类加载器加载到JVM里,JVM执行字节码,最终需要转化...

  • java执行过程

    Java代码在编译后会变成Java字节码,字节码被类加载器加载到JVM里,JVM执行字节 码,最终需要转化为汇编指...

  • Java并发机制的底层实现

    Java代码编译后会变成Java字节码,字节码被类加载器加载到JVM里,JVM执行字节码,最终需要转化为汇编指令在...

  • synchronized的实现原理与应用

    Java代码在编译后会变成Java字节码,字节码被类加载器加载到JVM里,JVM执行字节码,最终需要转化为汇编指令...

  • 原子操作的实现原理

    Java代码在编译后会变成Java字节码,字节码被类加载器加载到JVM里,JVM执行字节码,最终需要转化为汇编指令...

  • volatile的实现原理与应用

    Java代码在编译后会变成Java字节码,字节码被类加载器加载到JVM里,JVM执行字节码,最终需要转化为汇编指令...

网友评论

      本文标题:JVM字节码

      本文链接:https://www.haomeiwen.com/subject/ushcbrtx.html