Migration from Jasmin

Jasmin to JAL Migration Guide

If you’re coming from Jasmin, this guide will help you understand the key differences and advantages of switching to JAL (Java Assembly Language) for JVM bytecode development.

このページは日本語でもご覧いただけます。

---

1. Syntax and Structure

• Jasmin uses a more traditional assembler syntax that’s closer to raw JVM bytecode.
• JAL provides a structured, readable syntax that resembles Java but is specialized for bytecode manipulation.

Example: Class Declaration

Jasmin:

.class public MyClass
.super java/lang/Object

.method public <init>()V
  aload_0
  invokespecial java/lang/Object/<init>()V
  return
.end method

JAL:

public class MyClass (
  major_version=55,
  minor_version=0,
  super_class=java/lang/Object
) {
  public <init>()V {
    aload_0
    invokespecial java/lang/Object-><init>()V
    return
  }
}

JAL bundles class metadata (version, superclass) right in the class declaration, improving clarity.

Class Metadata (Additional Note)

In JAL, the major_version, minor_version, super_class, and interfaces metadata are all optional.
If omitted, the following default values are applied:

• major_version defaults to the JVM version of the JAL compiler runtime environment (e.g., the JVM version running the compiler)
• minor_version defaults to 0
• super_class defaults to java/lang/Object
• interfaces defaults to none (empty)

This means you can write a valid class declaration by specifying just the class name, making it easier to start coding quickly.

Example:

class SimpleClass {
// Defaults for version and superclass are automatically applied
}

---

2. Member References

• Jasmin uses dot-separated names for methods and fields (e.g., java/lang/Object.<init>).
• JAL uses -> for methods and / for fields with explicit type descriptors.

// Field reference example in JAL
getstatic java/lang/System/out:Ljava/io/PrintStream;

// Method reference example in JAL
invokevirtual java/io/PrintStream->println(Ljava/lang/String;)V;

This explicit referencing eliminates ambiguity and aligns closely with JVM internal naming.

---

3. Labels and Control Flow

• Jasmin uses labels with simple names and jumps.
• JAL uses similar labels but supports more readable structured exception handling directives and named locals.

LoopStart:
  iload_1
  bipush 10
  if_icmpge LoopEnd
  // ...
LoopEnd:
  return

---

4. Local Variables Naming

• Jasmin uses only numeric indices for local variables.
• JAL supports optional naming of local variables, improving readability:

istore 0 [->counter]
iload counter

---

5. Exception Handling

• Jasmin requires manual exception table directives.
• JAL allows defining try-catch-finally blocks with label-based, human-readable syntax:

tryStart: [~tryEnd, java/lang/Exception: catchStart, ->finallyStart]
tryEnd:
catchStart:
// handler code
finallyStart:
// finally code

---

6. StackMapFrames

• Jasmin often requires manual StackMapFrame management.
• JAL automatically generates StackMapFrames, saving you headaches and errors during verification.

---

7. Advantages of JAL Over Jasmin

Feature	Jasmin	JAL
Syntax Style	Traditional assembler	Java-like structured syntax
Class Metadata Declaration	Separate directives	Inline in class declaration
Member Reference Syntax	Dot notation	Explicit -> and / syntax
Local Variable Naming	Numeric only	Optional named locals
Exception Handling	Manual tables	Label-based try-catch-finally
StackMapFrame Management	Manual	Automatic
Readability & Maintainability	Moderate	Higher

---

8. Summary

• JAL’s syntax is cleaner, more expressive, and better suited for complex JVM bytecode projects.
• It reduces boilerplate and errors by automating tedious JVM details.
• JAL embraces JVM internal naming conventions explicitly, improving clarity and tooling support.

Switching from Jasmin to JAL means stepping up to a more modern, maintainable, and user-friendly JVM assembly language.

---

Happy bytecoding with JAL!