goto  12  ; absolute offset : go to bytecode at offset 12
goto +5   ; relative offset : go 12 bytes forward
goto -8   ; relative offset : go 8 bytes backwards

.bytecode 49.0

.debug "some string here"

.enclosing method "some/package/Foo/someMethod(I)V"

.signature "Signature()"
.field myField Ljava/lang/String; signature "Signature()"

       0: aload_0
       1: invokespecial java/lang/Object/()V
       4: aload_0
       5: ldc2_w 3.14159
  

JasminXT File Format

This new version is an extension of the existing Jasmin language, therefore old Jasmin files should still compile correctly with newer versions of Jasmin. JasminXT is supported by Jasmin 2.0 or higher. Changes in Jasmin 2.4 are in bold.

In the rest of this document, words between '[' and ']' are optional. The syntax of a JasminXT file is the following :

<jas_file> {
    <jasmin_header>
    [<field>]*
    [<method>]*
}

JasminXT Header

<jasmin_header> {
    [.bytecode <x.y>]
    [.source <sourcefile>]
    <class_spec>
    <super_spec>
    <implements>
    [.signature "<signature>"]
    [.enclosing method <method_name>]
    [.debug "<debug_source_extension>"]*
    [.inner class [<access>] [<name>] [inner <classname>] [outer <name>]]*
    [.inner interface [<access>] [<name>] [inner <classname>] [outer <name>]]*
}

example :
.bytecode 49.0
.source hello.j
.class hello
.super java/lang/Object
.signature "<my::own>Signature()"
.enclosing method foo/bar/Whatever/someMethod()

The .bytecode directive sets the version of the bytecode in the class file.

The .signature directive, when used in the header of the Jasmin file, sets the Signature attribute for the class (the argument is a string between double quotes)

The .enclosing directive sets the EnclosingMethod attribute for the class. The argument is a supposed to be a method name, but it can be any string between double quotes.

The .debug directive sets the SourceDebugExtension attribute for the class (the argument is also a string between double quotes)

JasminXT Class, Super Class and Interfaces Definition

<class_spec> {
    .class <access_spec> <class_name>
}

where <access_spec> is any number of words taken from this list : public, private, protected, static, final, synchronized, native, final, super, interface, abstract, annotation, enum, bridge/volatile, transient/varargs

and <class_name> is the fully qualified internal form of the class, such as my/package/MyClass

<super_spec> {
    .super <class_name>
}

<implements> {
    .implements <class_name>*
}

The .super and .implements directives have not been modified in JasminXT
The .implements directive can be repeated in order to implement multiple interfaces

JasminXT Field Definition

<field> {
    .field <access_spec> <field_name> <descriptor> [signature <signature>]
           [ = <value> ]
    |
    .field <access_spec> <field_name> <descriptor> [signature <signature>]
           [ = <value> ]
        [<field_attribute>]*
    .end field
   (...)
}

If present, the Signature attribute will be set in the class file for this field with the given quoted string as an argument.

<field_attribute> {
    .deprecated
  | .attribute <name> <file_name>
  | .signature <signature>
  | .annotation (...)
}

examples :

.field enum myField Ljava/lang/String; signature "<my::own>Signature()" = "val"

.field static hello_string Ljava/lang/String;
    .signature "mySignature"
    .deprecated
.end field

JasminXT Method Definition

<method> {
    .method <access_spec> <method_name> <descriptor>
        <statement>*
    .end method
}

JasminXT Method Statements

<statement> {
   .limit stack <integer>
   | .limit locals <integer>
   | .line <integer>
   | .var <var_number> is <var_name> <descriptor> [signature <sign>] from <label1> to <label2>
   | .var <var_number> is <var_name> <descriptor> [signature <sign>] from <offset1> to <offset2>
   | .throws <classname>
   | .catch <classname> from <label1> to <label2> using <label3>
   | .catch <classname> from <offset1> to <offset2> using <offset3>
   | .signature "<signature>"
   | .stack
         [offset {<pc> | <label>}]
         [locals <verification_type> [<verification_arg>]]
         (...)
         [stack  <verification_type> [<verification_arg>]]
         (...)
     .end stack
   | .stack use [n] locals
         (...)
     .end stack
   | <instruction> [<instruction_args>]
   | <Label>:
   | .deprecated
   | <generic> ; see below for the use of generic attributes
}

In Jasmin XT you can now use offsets instead of labels for the local variable definitions and for the exception handlers definitions.

The .signature sets the Signature attribute for this method with the given quoted string.

You can now also define StackMap (or StackMapTable) attributes using the .stack directive. <pc> is an offset in the local bytecode array. <verification_type> is one of the following keywords : Top, Integer, Float, Long, Double, Null, UninitializedThis, Object or Uninitialized. Object takes a <classname> as a parameter. Uninitialized takes an integer or a label as a parameter. Also, jasmin allows to use "short" notation. The '.stack use [n] locals' directive results in copy first <n> values from previous .stack directive. If <n> is omitted, all values are copied.

NOTE: If bytecode version is 50 or above jasmin generates StackMapTable attribute in accordance with specification of the new 'ClassFile Format' edition. If bytecode version is 49 or below jasmin generate StakMap attribute in accordance with CLDC specification.

examples :

.stack
    offset 16
    locals Null
    locals Top
    locals Object allo
    stack Uninitialized 12
.end stack

.stack
    ; offset is not specified, the offset of the current opcode will be used
    locals Null
    locals Top
    locals Object allo
    stack Uninitialized Label0
.end stack

This statement defines a single stack map frame. All the stack map frames defined in a method are then aggregated and form the StackMap attribute for the method. The last example my be wrote at the short notation as:

.stack use locals
    stack Uninitialized Label0
.end stack

JasminXT Instructions

<instruction> {
    [<pc>:] <opcode> [<instruction_args>]
}

The main change in JasminXT is that it is now possible to put the offset of the instruction before the opcode (the <pc>: statement). The pc is processed as a label, therefore you can virtually put any number as the pc but it won't change the actual pc of the bytecode.

Another update is that it is now possible to use offsets (both relative and absolute) as branch targets instead of labels. The offset is considered to be relative if it begins with '$+' or '$-'.

goto  n  ; absolute offset : go to the bytecode labelled n
goto $+n  ; relative offset : go n bytes forward (from the offset of this goto)
goto $-n  ; relative offset : go n bytes backwards

If something hasn't been documented here, it means that it hasn't changed, so you can still refer to the Jasmin user guide

Added '_w' aliase to [adfli]-load/store, iinc and ret instructions (e.g. aload - aload_w). Using '_w' postfix guarantees wide-form of byte-code generation

Generic Attributes

<generic> = {
    .attribute <name> <file_name>
}

Annotations

Added a new directive .annotation to create the AnnotationDefault, RuntimeVisibleAnnotation, RuntimeInvisibleAnnotation, RuntimeVisibeParameterAnnotation, RuntimeInvisibleParameterAnnotation attributes. The directive arguments are verified to have valid values and correct signatures.
Complex (nested) annotations are supported as well as arrays of them.
The generic format is:

<annotation> = {
    .annotation visible <classname>
  | .annotation invisible <classname>>
  | .annotation visibleparam <paramnum> <classname>
  | .annotation invisibleparam <paramnum> <classname>
  | .annotation default
         ........
    .end annotation

Field format (except AnnotationDefault):

    <name> <signchar> = <value>*
  | <name> @ = .annotation
            ........
    .end annotation
}