bsh.org.objectweb.asm.Label Maven / Gradle / Ivy
The newest version!
/*
* #%L
* The AIBench Shell Plugin
* %%
* Copyright (C) 2006 - 2017 Daniel Glez-Peña and Florentino Fdez-Riverola
* %%
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Lesser Public License for more details.
*
* You should have received a copy of the GNU General Lesser Public
* License along with this program. If not, see
* .
* #L%
*/
/***
* ASM: a very small and fast Java bytecode manipulation framework
* Copyright (C) 2000 INRIA, France Telecom
* Copyright (C) 2002 France Telecom
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* Contact: [email protected]
*
* Author: Eric Bruneton
*/
package bsh.org.objectweb.asm;
/**
* 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.
*/
public class Label {
/**
* The code writer to which this label belongs, or null if
* unknown.
*/
CodeWriter owner;
/**
* Indicates if the position of this label is known.
*/
boolean resolved;
/**
* The position of this label in the code, if known.
*/
int position;
/**
* Number of forward references to this label, times two.
*/
private int referenceCount;
/**
* 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.
*/
private int[] srcAndRefPositions;
// --------------------------------------------------------------------------
// Fields for the control flow graph analysis algorithm (used to compute
// the
// maximum stack size). A control flow graph contains one node per
// "basic
// block", and one edge per "jump" from one basic block to another. Each
// node
// (i.e., each basic block) is represented by the Label object that
// corresponds to the first instruction of this basic block. Each node
// also
// stores the list of it successors in the graph, as a linked list of
// Edge
// objects.
// --------------------------------------------------------------------------
/**
* 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 beginStackSize;
/**
* 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}.
*/
int maxStackSize;
/**
* 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.
*/
Edge successors;
/**
* The next basic block in the basic block stack. See
* {@link CodeWriter#visitMaxs visitMaxs}.
*/
Label next;
/**
* true if this basic block has been pushed in the basic
* block stack. See {@link CodeWriter#visitMaxs visitMaxs}.
*/
boolean pushed;
// --------------------------------------------------------------------------
// Constructor
// --------------------------------------------------------------------------
/**
* Constructs a new label.
*/
public Label() {
}
// --------------------------------------------------------------------------
// Methods to compute offsets and to manage forward references
// --------------------------------------------------------------------------
/**
* 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.
*/
void put(final CodeWriter owner, final ByteVector out, final int source, final boolean wideOffset) {
if (CodeWriter.CHECK) {
if (this.owner == null) {
this.owner = owner;
} else if (this.owner != owner) {
throw new IllegalArgumentException();
}
}
if (resolved) {
if (wideOffset) {
out.put4(position - source);
} else {
out.put2(position - source);
}
} else {
if (wideOffset) {
addReference(-1 - source, out.length);
out.put4(-1);
} else {
addReference(source, out.length);
out.put2(-1);
}
}
}
/**
* 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.
*/
private void addReference(final int sourcePosition, final int referencePosition) {
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;
}
/**
* 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.
*/
boolean resolve(final CodeWriter owner, final int position, final byte[] data) {
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;
}
}
© 2015 - 2024 Weber Informatics LLC | Privacy Policy