Apakah ada kompiler untuk JVM yang menggunakan goto "lebar"?

Saya pikir sebagian besar dari Anda tahu bahwa gotokata kunci yang disediakan dalam bahasa Jawa tetapi tidak benar-benar digunakan. Dan Anda mungkin juga tahu itu gotoadalah opcode Java Virtual Machine (JVM). Saya rasa semua struktur aliran kontrol canggih dari Jawa, Scala dan Kotlin yang, pada tingkat JVM, dilaksanakan dengan menggunakan beberapa kombinasi dari gotodan ifeq, ifle, iflt, dll

Melihat spesifikasi JVM https://docs.oracle.com/javase/specs/jvms/se7/html/jvms-6.html#jvms-6.5.goto_w Saya melihat ada juga goto_wopcode. Sedangkan gotomengambil cabang offset 2-byte, goto_wmengambil cabang offset 4-byte. Spesifikasi menyatakan itu

Meskipun instruksi goto_w mengambil offset cabang 4-byte, faktor lain membatasi ukuran metode hingga 65535 byte (§4.11). Batas ini dapat dinaikkan pada rilis Java Virtual Machine yang akan datang.

Bagi saya kedengarannya seperti goto_wpembuktian di masa depan, seperti beberapa *_wopcode lainnya . Tetapi itu juga terjadi pada saya bahwa mungkin goto_wdapat digunakan dengan dua byte lebih signifikan memusatkan perhatian dan dua byte kurang signifikan sama seperti untuk goto, dengan penyesuaian yang diperlukan.

Sebagai contoh, dengan diberikan Java Switch-Case (atau Scala Match-Case):

     12: lookupswitch  {
                112785: 48 // case "red"
               3027034: 76 // case "green"
              98619139: 62 // case "blue"
               default: 87
          }
      48: aload_2
      49: ldc           #17                 // String red
      51: invokevirtual #18
            // Method java/lang/String.equals:(Ljava/lang/Object;)Z
      54: ifeq          87
      57: iconst_0
      58: istore_3
      59: goto          87
      62: aload_2
      63: ldc           #19                 // String green
      65: invokevirtual #18
            // Method java/lang/String.equals:(Ljava/lang/Object;)Z
      68: ifeq          87
      71: iconst_1
      72: istore_3
      73: goto          87
      76: aload_2
      77: ldc           #20                 // String blue
      79: invokevirtual #18 
      // etc.

kita bisa menulis ulang sebagai

     12: lookupswitch  { 
                112785: 48
               3027034: 78
              98619139: 64
               default: 91
          }
      48: aload_2
      49: ldc           #17                 // String red
      51: invokevirtual #18
            // Method java/lang/String.equals:(Ljava/lang/Object;)Z
      54: ifeq          91 // 00 5B
      57: iconst_0
      58: istore_3
      59: goto_w        91 // 00 00 00 5B
      64: aload_2
      65: ldc           #19                 // String green
      67: invokevirtual #18
            // Method java/lang/String.equals:(Ljava/lang/Object;)Z
      70: ifeq          91
      73: iconst_1
      74: istore_3
      75: goto_w          91
      79: aload_2
      81: ldc           #20                 // String blue
      83: invokevirtual #18 
      // etc.

Saya belum benar-benar mencoba ini, karena saya mungkin telah membuat kesalahan dengan mengubah "nomor baris" untuk mengakomodasi goto_w. Tetapi karena itu ada dalam spesifikasi, itu harus dimungkinkan untuk melakukannya.

Pertanyaan saya adalah apakah ada alasan kompiler atau generator bytecode lainnya dapat digunakan goto_wdengan batas 65535 saat ini selain untuk menunjukkan bahwa hal itu dapat dilakukan?

Ukuran kode metode bisa sebesar 64K.

Offset cabang pendek gotoadalah bilangan bulat 16-bit yang ditandatangani: dari -32768 hingga 32767.

Jadi, offset pendek tidak cukup untuk melakukan lompatan dari awal metode 65K ke akhir.

Bahkan javacterkadang memancarkan goto_w. Berikut ini sebuah contoh:

public class WideGoto {

    public static void main(String[] args) {
        for (int i = 0; i < 1_000_000_000; ) {
            i += 123456;
            // ... repeat 10K times ...
        }
    }
}

Mengurai dengan javap -c:

  public static void main(java.lang.String[]);
    Code:
       0: iconst_0
       1: istore_1
       2: iload_1
       3: ldc           #2
       5: if_icmplt     13
       8: goto_w        50018     // <<< Here it is! A jump to the end of the loop
          ...

Tidak ada alasan untuk digunakan goto_wsaat cabang cocok dengan a goto. Tetapi Anda tampaknya telah melewatkan bahwa cabang adalah relatif , menggunakan offset yang ditandatangani, karena cabang juga dapat mundur.

Anda tidak melihatnya ketika melihat output dari alat seperti javap, karena menghitung alamat target absolut yang dihasilkan sebelum mencetak.

Jadi gotojangkauan -327678 … +32767‬tidak selalu cukup untuk mengatasi setiap kemungkinan lokasi target dalam 0 … +65535jangkauan.

Misalnya, metode berikut akan memiliki goto_winstruksi di awal:

public static void methodWithLargeJump(int i) {
    for(; i == 0;) {
        try {x();} finally { switch(i){ case 1: try {x();} finally { switch(i){ case 1: 
        try {x();} finally { switch(i){ case 1: try {x();} finally { switch(i){ case 1: 
        try {x();} finally { switch(i){ case 1: try {x();} finally { switch(i){ case 1: 
        try {x();} finally { switch(i){ case 1: try {x();} finally { switch(i){ case 1: 
        try {x();} finally { switch(i){ case 1: try {x();} finally { switch(i){ case 1: 
        } } } } } } } } } } } } } } } } } } } } 
    }
}
static void x() {}

Demo di Ideone

Compiled from "Main.java"
class LargeJump {
  public static void methodWithLargeJump(int);
    Code:
       0: iload_0
       1: ifeq          9
       4: goto_w        57567
…

Tampaknya dalam beberapa kompiler (dicoba pada 1.6.0 dan 11.0.7), jika suatu metode cukup besar yang pernah membutuhkan goto_w, ia menggunakan secara eksklusif goto_w. Bahkan ketika ia memiliki lompatan yang sangat lokal, ia masih menggunakan goto_w.