FileDocCategorySizeDatePackage
Label.javaAPI DocGlassfish v2 API11741Thu Mar 02 11:51:12 GMT 2006oracle.toplink.libraries.asm

Label

public class Label extends Object
A label represents a position in the bytecode of a method. Labels are used for jump, goto, and switch instructions, and for try catch blocks.
author
Eric Bruneton

Fields Summary
CodeWriter
owner
The code writer to which this label belongs, or null if unknown.
int
line
The line number corresponding to this label, if known.
boolean
resolved
Indicates if the position of this label is known.
int
position
The position of this label in the code, if known.
boolean
resized
If the label position has been updated, after instruction resizing.
private int
referenceCount
Number of forward references to this label, times two.
private int[]
srcAndRefPositions
Informations about forward references. Each forward reference is described by two consecutive integers in this array: the first one is the position of the first byte of the bytecode instruction that contains the forward reference, while the second is the position of the first byte of the forward reference itself. In fact the sign of the first integer indicates if this reference uses 2 or 4 bytes, and its absolute value gives the position of the bytecode instruction.
int
beginStackSize
The stack size at the beginning of this basic block. This size is initially unknown. It is computed by the control flow analysis algorithm (see {@link CodeWriter#visitMaxs visitMaxs}).
int
maxStackSize
The (relative) maximum stack size corresponding to this basic block. This size is relative to the stack size at the beginning of the basic block, i.e., the true maximum stack size is equal to {@link #beginStackSize beginStackSize} + {@link #maxStackSize maxStackSize}.
Edge
successors
The successors of this node in the control flow graph. These successors are stored in a linked list of {@link Edge Edge} objects, linked to each other by their {@link Edge#next} field.
Label
next
The next basic block in the basic block stack. See {@link CodeWriter#visitMaxs visitMaxs}.
boolean
pushed
true if this basic block has been pushed in the basic block stack. See {@link CodeWriter#visitMaxs visitMaxs}.
Constructors Summary
public Label()
Constructs a new label.
Methods Summary
private voidaddReference(int sourcePosition, int referencePosition)
Adds a forward reference to this label. This method must be called only for a true forward reference, i.e. only if this label is not resolved yet. For backward references, the offset of the reference can be, and must be, computed and stored directly.

param
sourcePosition the position of the referencing instruction. This position will be used to compute the offset of this forward reference.
param
referencePosition the position where the offset for this forward reference must be stored.

    if (srcAndRefPositions == null) {
      srcAndRefPositions = new int[6];
    }
    if (referenceCount >= srcAndRefPositions.length) {
      int[] a = new int[srcAndRefPositions.length + 6];
      System.arraycopy(srcAndRefPositions, 0, a, 0, srcAndRefPositions.length);
      srcAndRefPositions = a;
    }
    srcAndRefPositions[referenceCount++] = sourcePosition;
    srcAndRefPositions[referenceCount++] = referencePosition;
public intgetOffset()
Returns the offset corresponding to this label. This offset is computed from the start of the method's bytecode. This method is intended for {@link Attribute} sub classes, and is normally not needed by class generators or adapters.

return
the offset corresponding to this label.
throws
IllegalStateException if this label is not resolved yet.

    if (!resolved) {
      throw new IllegalStateException(
        "Label offset position has not been resolved yet");
    }
    return position;
voidput(oracle.toplink.libraries.asm.CodeWriter owner, oracle.toplink.libraries.asm.ByteVector out, int source, boolean wideOffset)
Puts a reference to this label in the bytecode of a method. If the position of the label is known, the offset is computed and written directly. Otherwise, a null offset is written and a new forward reference is declared for this label.

param
owner the code writer that calls this method.
param
out the bytecode of the method.
param
source the position of first byte of the bytecode instruction that contains this label.
param
wideOffset true if the reference must be stored in 4 bytes, or false if it must be stored with 2 bytes.
throws
IllegalArgumentException if this label has not been created by the given code writer.

    if (CodeWriter.CHECK) {
      if (this.owner == null) {
        this.owner = owner;
      } else if (this.owner != owner) {
        throw new IllegalArgumentException();
      }
    }
    if (resolved) {
      if (wideOffset) {
        out.putInt(position - source);
      } else {
        out.putShort(position - source);
      }
    } else {
      if (wideOffset) {
        addReference(-1 - source, out.length);
        out.putInt(-1);
      } else {
        addReference(source, out.length);
        out.putShort(-1);
      }
    }
booleanresolve(oracle.toplink.libraries.asm.CodeWriter owner, int position, byte[] data)
Resolves all forward references to this label. This method must be called when this label is added to the bytecode of the method, i.e. when its position becomes known. This method fills in the blanks that where left in the bytecode by each forward reference previously added to this label.

param
owner the code writer that calls this method.
param
position the position of this label in the bytecode.
param
data the bytecode of the method.
return
true if a blank that was left for this label was to small to store the offset. In such a case the corresponding jump instruction is replaced with a pseudo instruction (using unused opcodes) using an unsigned two bytes offset. These pseudo instructions will need to be replaced with true instructions with wider offsets (4 bytes instead of 2). This is done in {@link CodeWriter#resizeInstructions}.
throws
IllegalArgumentException if this label has already been resolved, or if it has not been created by the given code writer.

    if (CodeWriter.CHECK) {
      if (this.owner == null) {
        this.owner = owner;
      }
      if (resolved || this.owner != owner) {
        throw new IllegalArgumentException();
      }
    }
    boolean needUpdate = false;
    this.resolved = true;
    this.position = position;
    int i = 0;
    while (i < referenceCount) {
      int source = srcAndRefPositions[i++];
      int reference = srcAndRefPositions[i++];
      int offset;
      if (source >= 0) {
        offset = position - source;
        if (offset < Short.MIN_VALUE || offset > Short.MAX_VALUE) {
          // changes the opcode of the jump instruction, in order to be able to
          // find it later (see resizeInstructions in CodeWriter). These
          // temporary opcodes are similar to jump instruction opcodes, except
          // that the 2 bytes offset is unsigned (and can therefore represent
          // values from 0 to 65535, which is sufficient since the size of a
          // method is limited to 65535 bytes).
          int opcode = data[reference - 1] & 0xFF;
          if (opcode <= Constants.JSR) {
            // changes IFEQ ... JSR to opcodes 202 to 217 (inclusive)
            data[reference - 1] = (byte)(opcode + 49);
          } else {
            // changes IFNULL and IFNONNULL to opcodes 218 and 219 (inclusive)
            data[reference - 1] = (byte)(opcode + 20);
          }
          needUpdate = true;
        }
        data[reference++] = (byte)(offset >>> 8);
        data[reference] = (byte)offset;
      } else {
        offset = position + source + 1;
        data[reference++] = (byte)(offset >>> 24);
        data[reference++] = (byte)(offset >>> 16);
        data[reference++] = (byte)(offset >>> 8);
        data[reference] = (byte)offset;
      }
    }
    return needUpdate;
public java.lang.StringtoString()
Returns a string representation of this label.

return
a string representation of this label.

    return "L" + System.identityHashCode(this);