[JAVA] Assemblage inversé / fichier .class de compilation inverse compilé à partir de Kotlin

Il s'agit d'une expérience utilisant javap (assembleur inverse) et jad (compilateur inverse) pour le code Kotlin.

hello.kt

fun main(args: Array<String>) {
    println("Hello, World!")
}

Source du code https://kotlinlang.org/docs/tutorials/command-line.html

Kotlin, comme tout autre langage JVM, est compilé dans un fichier de classe qui peut être exécuté en Java. J'ai essayé de vérifier cela car il est possible d'afficher les mnémoniques JVM avec javap et de les compiler en sens inverse en tant que code source java avec jad.

compiler

kotlinc hello.kt -include-runtime -d hello.jar

Développez jar et utilisez javap, jad pour hello.class

jar xf hello.jar

environnement

macOS High Sierra 10

javap (assembleur inversé)

Préparation

Non requis car il est inclus dans le JDK depuis le début

Courir

commander

javap -c HelloKt.class

résultat

Compiled from "hello.kt"
public final class HelloKt {
  public static final void main(java.lang.String[]);
    Code:
       0: aload_0
       1: ldc           #9                  // String args
       3: invokestatic  #15                 // Method kotlin/jvm/internal/Intrinsics.checkParameterIsNotNull:(Ljava/lang/Object;Ljava/lang/String;)V
       6: ldc           #17                 // String Hello, World!
       8: astore_1
       9: getstatic     #23                 // Field java/lang/System.out:Ljava/io/PrintStream;
      12: aload_1
      13: invokevirtual #29                 // Method java/io/PrintStream.println:(Ljava/lang/Object;)V
      16: return
}

jad (compilateur inverse)

Préparation

Comment installer jad

brew tap caskroom/cask
brew install caskroom/cask/jad

Site référencé http://inarizuuuushi.hatenablog.com/entry/2017/05/09/231600

Courir

Vous pouvez afficher les mnémoniques sous forme de commentaires avec l'option -a.

commander

$ jad  -a HelloKt.class 
$ cat HelloKt.jad 

python

import java.io.PrintStream;
import kotlin.jvm.internal.Intrinsics;

public final class HelloKt
{

    public static final void main(String args[])
    {
        Intrinsics.checkParameterIsNotNull(args, "args");
    //    0    0:aload_0         
    //    1    1:ldc1            #9   <String "args">
    //    2    3:invokestatic    #15  <Method void Intrinsics.checkParameterIsNotNull(Object, String)>
        String s = "Hello, World!";
    //    3    6:ldc1            #17  <String "Hello, World!">
    //    4    8:astore_1        
        System.out.println(s);
    //    5    9:getstatic       #23  <Field PrintStream System.out>
    //    6   12:aload_1         
    //    7   13:invokevirtual   #29  <Method void PrintStream.println(Object)>
    //    8   16:return          
    }
}

C'était assez facile à présenter et à analyser. À l'avenir, j'essaierai de vérifier à portée de main comment les fonctions spécifiques à Kotlin sont exprimées et converties en Java.