InstructionList.java
package org.aspectj.apache.bcel.generic;
/* ====================================================================
* The Apache Software License, Version 1.1
*
* Copyright (c) 2001 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* 3. The end-user documentation included with the redistribution,
* if any, must include the following acknowledgment:
* "This product includes software developed by the
* Apache Software Foundation (https://www.apache.org/)."
* Alternately, this acknowledgment may appear in the software itself,
* if and wherever such third-party acknowledgments normally appear.
*
* 4. The names "Apache" and "Apache Software Foundation" and
* "Apache BCEL" must not be used to endorse or promote products
* derived from this software without prior written permission. For
* written permission, please contact apache@apache.org.
*
* 5. Products derived from this software may not be called "Apache",
* "Apache BCEL", nor may "Apache" appear in their name, without
* prior written permission of the Apache Software Foundation.
*
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
* ====================================================================
*
* This software consists of voluntary contributions made by many
* individuals on behalf of the Apache Software Foundation. For more
* information on the Apache Software Foundation, please see
* <https://www.apache.org/>.
*/
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import org.aspectj.apache.bcel.Constants;
import org.aspectj.apache.bcel.classfile.Constant;
import org.aspectj.apache.bcel.classfile.ConstantPool;
import org.aspectj.apache.bcel.util.ByteSequence;
/**
* This class is a container for a list of <a href="Instruction.html">Instruction</a> objects. Instructions can be appended,
* inserted, moved, deleted, etc.. Instructions are being wrapped into <a href="InstructionHandle.html">InstructionHandles</a>
* objects that are returned upon append/insert operations. They give the user (read only) access to the list structure, such that
* it can be traversed and manipulated in a controlled way.
*
* A list is finally dumped to a byte code array with <a href="#getByteCode()">getByteCode</a>.
*
* @version $Id: InstructionList.java,v 1.12 2011/09/02 22:33:04 aclement Exp $
* @author <A HREF="mailto:markus.dahm@berlin.de">M. Dahm</A>
* @author Abraham Nevado
* @see Instruction
* @see InstructionHandle
* @see BranchHandle
*/
public class InstructionList implements Serializable {
private InstructionHandle start = null, end = null;
private int length = 0;
private int[] positions; // byte code offsets corresponding to instructions
public InstructionList() {
}
public InstructionList(Instruction i) {
append(i);
}
public boolean isEmpty() {
return start == null;
} // && end == null
public static InstructionHandle findHandle(InstructionHandle[] ihs, int[] pos, int count, int target) {
return findHandle(ihs, pos, count, target, false);
}
/**
* Find the target instruction (handle) that corresponds to the given target position (byte code offset).
*
* @param ihs array of instruction handles, i.e. il.getInstructionHandles()
* @param pos array of positions corresponding to ihs, i.e. il.getInstructionPositions()
* @param count length of arrays
* @param target target position to search for
* @return target position's instruction handle if available
*/
public static InstructionHandle findHandle(InstructionHandle[] ihs, int[] pos, int count, int target,
boolean returnClosestIfNoExactMatch) {
int l = 0, r = count - 1;
// Do a binary search since the pos array is ordered
int i, j;
do {
i = (l + r) / 2;
j = pos[i];
if (j == target) {
return ihs[i]; // found it
} else if (target < j) {
r = i - 1; // else constrain search area
} else {
l = i + 1; // target > j
}
} while (l <= r);
if (returnClosestIfNoExactMatch) {
i = (l + r) / 2;
if (i < 0) {
i = 0;
}
return ihs[i];
}
return null;
}
/**
* Get instruction handle for instruction at byte code position pos. This only works properly, if the list is freshly
* initialized from a byte array or setPositions() has been called before this method.
*
* @param pos byte code position to search for
* @return target position's instruction handle if available
*/
public InstructionHandle findHandle(int pos) {
InstructionHandle[] ihs = getInstructionHandles();
return findHandle(ihs, positions, length, pos);
}
public InstructionHandle[] getInstructionsAsArray() {
return getInstructionHandles();
}
public InstructionHandle findHandle(int pos, InstructionHandle[] instructionArray) {
return findHandle(instructionArray, positions, length, pos);
}
public InstructionHandle findHandle(int pos, InstructionHandle[] instructionArray, boolean useClosestApproximationIfNoExactFound) {
return findHandle(instructionArray, positions, length, pos, useClosestApproximationIfNoExactFound);
}
/**
* Initialize instruction list from byte array.
*
* @param code byte array containing the instructions
*/
public InstructionList(byte[] code) {
ByteSequence bytes = new ByteSequence(code);
InstructionHandle[] ihs = new InstructionHandle[code.length];
int[] pos = new int[code.length]; // Can't be more than that
int count = 0; // Contains actual length
/*
* Pass 1: Create an object for each byte code and append them to the list.
*/
try {
while (bytes.available() > 0) {
// Remember byte offset and associate it with the instruction
int off = bytes.getIndex();
pos[count] = off;
/*
* Read one instruction from the byte stream, the byte position is set accordingly.
*/
Instruction i = Instruction.readInstruction(bytes);
InstructionHandle ih;
if (i instanceof InstructionBranch) {
ih = append((InstructionBranch) i);
} else {
ih = append(i);
}
ih.setPosition(off);
ihs[count] = ih;
count++;
}
} catch (IOException e) {
throw new ClassGenException(e.toString());
}
positions = new int[count]; // Trim to proper size
System.arraycopy(pos, 0, positions, 0, count);
/*
* Pass 2: Look for BranchInstruction and update their targets, i.e., convert offsets to instruction handles.
*/
// OPTIMIZE better way of doing this? keep little map from earlier from pos -> instruction handle?
for (int i = 0; i < count; i++) {
if (ihs[i] instanceof BranchHandle) {
InstructionBranch bi = (InstructionBranch) ihs[i].instruction;
int target = bi.positionOfThisInstruction + bi.getIndex(); /*
* Byte code position: relative -> absolute.
*/
// Search for target position
InstructionHandle ih = findHandle(ihs, pos, count, target);
if (ih == null) {
throw new ClassGenException("Couldn't find target for branch: " + bi);
}
bi.setTarget(ih); // Update target
// If it is a Select instruction, update all branch targets
if (bi instanceof InstructionSelect) { // Either LOOKUPSWITCH or TABLESWITCH
InstructionSelect s = (InstructionSelect) bi;
int[] indices = s.getIndices();
for (int j = 0; j < indices.length; j++) {
target = bi.positionOfThisInstruction + indices[j];
ih = findHandle(ihs, pos, count, target);
if (ih == null) {
throw new ClassGenException("Couldn't find target for switch: " + bi);
}
s.setTarget(j, ih); // Update target
}
}
}
}
}
/**
* Append another list after instruction (handle) ih contained in this list. Consumes argument list, i.e., it becomes empty.
*
* @param appendTo where to append the instruction list
* @param appendee Instruction list to append to this one
* @return instruction handle pointing to the <B>first</B> appended instruction
*/
public InstructionHandle append(InstructionHandle appendTo, InstructionList appendee) {
assert appendee != null;
if (appendee.isEmpty()) {
return appendTo;
}
InstructionHandle next = appendTo.next;
InstructionHandle ret = appendee.start;
appendTo.next = appendee.start;
appendee.start.prev = appendTo;
appendee.end.next = next;
if (next != null) {
next.prev = appendee.end;
} else {
end = appendee.end; // Update end ...
}
length += appendee.length; // Update length
appendee.clear();
return ret;
}
/**
* Append another list after instruction i contained in this list. Consumes argument list, i.e., it becomes empty.
*
* @param i where to append the instruction list
* @param il Instruction list to append to this one
* @return instruction handle pointing to the <B>first</B> appended instruction
*/
public InstructionHandle append(Instruction i, InstructionList il) {
InstructionHandle ih;
if ((ih = findInstruction2(i)) == null) {
throw new ClassGenException("Instruction " + i + " is not contained in this list.");
}
return append(ih, il);
}
/**
* Append another list to this one. Consumes argument list, i.e., it becomes empty.
*
* @param il list to append to end of this list
* @return instruction handle of the <B>first</B> appended instruction
*/
public InstructionHandle append(InstructionList il) {
assert il != null;
if (il.isEmpty()) {
return null;
}
if (isEmpty()) {
start = il.start;
end = il.end;
length = il.length;
il.clear();
return start;
} else {
return append(end, il); // was end.instruction
}
}
/**
* Append an instruction to the end of this list.
*
* @param ih instruction to append
*/
private void append(InstructionHandle ih) {
if (isEmpty()) {
start = end = ih;
ih.next = ih.prev = null;
} else {
end.next = ih;
ih.prev = end;
ih.next = null;
end = ih;
}
length++; // Update length
}
/**
* Append an instruction to the end of this list.
*
* @param i instruction to append
* @return instruction handle of the appended instruction
*/
public InstructionHandle append(Instruction i) {
InstructionHandle ih = InstructionHandle.getInstructionHandle(i);
append(ih);
return ih;
}
public InstructionHandle appendDUP() {
InstructionHandle ih = InstructionHandle.getInstructionHandle(InstructionConstants.DUP);
append(ih);
return ih;
}
public InstructionHandle appendNOP() {
InstructionHandle ih = InstructionHandle.getInstructionHandle(InstructionConstants.NOP);
append(ih);
return ih;
}
public InstructionHandle appendPOP() {
InstructionHandle ih = InstructionHandle.getInstructionHandle(InstructionConstants.POP);
append(ih);
return ih;
}
/**
* Append a branch instruction to the end of this list.
*
* @param i branch instruction to append
* @return branch instruction handle of the appended instruction
*/
public BranchHandle append(InstructionBranch i) {
BranchHandle ih = BranchHandle.getBranchHandle(i);
append(ih);
return ih;
}
/**
* Append a single instruction j after another instruction i, which must be in this list of course!
*
* @param i Instruction in list
* @param j Instruction to append after i in list
* @return instruction handle of the first appended instruction
*/
public InstructionHandle append(Instruction i, Instruction j) {
return append(i, new InstructionList(j));
}
/**
* Append an instruction after instruction (handle) ih contained in this list.
*
* @param ih where to append the instruction list
* @param i Instruction to append
* @return instruction handle pointing to the <B>first</B> appended instruction
*/
public InstructionHandle append(InstructionHandle ih, Instruction i) {
return append(ih, new InstructionList(i));
}
/**
* Append an instruction after instruction (handle) ih contained in this list.
*
* @param ih where to append the instruction list
* @param i Instruction to append
* @return instruction handle pointing to the <B>first</B> appended instruction
*/
public BranchHandle append(InstructionHandle ih, InstructionBranch i) {
BranchHandle bh = BranchHandle.getBranchHandle(i);
InstructionList il = new InstructionList();
il.append(bh);
append(ih, il);
return bh;
}
/**
* Insert another list before Instruction handle ih contained in this list. Consumes argument list, i.e., it becomes empty.
*
* @param i where to append the instruction list
* @param il Instruction list to insert
* @return instruction handle of the first inserted instruction
*/
public InstructionHandle insert(InstructionHandle ih, InstructionList il) {
if (il == null) {
throw new ClassGenException("Inserting null InstructionList");
}
if (il.isEmpty()) {
return ih;
}
InstructionHandle prev = ih.prev, ret = il.start;
ih.prev = il.end;
il.end.next = ih;
il.start.prev = prev;
if (prev != null) {
prev.next = il.start;
} else {
start = il.start; // Update start ...
}
length += il.length; // Update length
il.clear();
return ret;
}
/**
* Insert another list.
*
* @param il list to insert before start of this list
* @return instruction handle of the first inserted instruction
*/
public InstructionHandle insert(InstructionList il) {
if (isEmpty()) {
append(il); // Code is identical for this case
return start;
} else {
return insert(start, il);
}
}
/**
* Insert an instruction at start of this list.
*
* @param ih instruction to insert
*/
private void insert(InstructionHandle ih) {
if (isEmpty()) {
start = end = ih;
ih.next = ih.prev = null;
} else {
start.prev = ih;
ih.next = start;
ih.prev = null;
start = ih;
}
length++;
}
/**
* Insert another list before Instruction i contained in this list. Consumes argument list, i.e., it becomes empty.
*
* @param i where to append the instruction list
* @param il Instruction list to insert
* @return instruction handle pointing to the first inserted instruction, i.e., il.getStart()
*/
public InstructionHandle insert(Instruction i, InstructionList il) {
InstructionHandle ih;
if ((ih = findInstruction1(i)) == null) {
throw new ClassGenException("Instruction " + i + " is not contained in this list.");
}
return insert(ih, il);
}
/**
* Insert an instruction at start of this list.
*
* @param i instruction to insert
* @return instruction handle of the inserted instruction
*/
public InstructionHandle insert(Instruction i) {
InstructionHandle ih = InstructionHandle.getInstructionHandle(i);
insert(ih);
return ih;
}
/**
* Insert a branch instruction at start of this list.
*
* @param i branch instruction to insert
* @return branch instruction handle of the appended instruction
*/
public BranchHandle insert(InstructionBranch i) {
BranchHandle ih = BranchHandle.getBranchHandle(i);
insert(ih);
return ih;
}
/**
* Insert a single instruction j before another instruction i, which must be in this list of course!
*
* @param i Instruction in list
* @param j Instruction to insert before i in list
* @return instruction handle of the first inserted instruction
*/
public InstructionHandle insert(Instruction i, Instruction j) {
return insert(i, new InstructionList(j));
}
/**
* Insert an instruction before instruction (handle) ih contained in this list.
*
* @param ih where to insert to the instruction list
* @param i Instruction to insert
* @return instruction handle of the first inserted instruction
*/
public InstructionHandle insert(InstructionHandle ih, Instruction i) {
return insert(ih, new InstructionList(i));
}
/**
* Insert an instruction before instruction (handle) ih contained in this list.
*
* @param ih where to insert to the instruction list
* @param i Instruction to insert
* @return instruction handle of the first inserted instruction
*/
public BranchHandle insert(InstructionHandle ih, InstructionBranch i) {
BranchHandle bh = BranchHandle.getBranchHandle(i);
InstructionList il = new InstructionList();
il.append(bh);
insert(ih, il);
return bh;
}
/**
* Take all instructions (handles) from "start" to "end" and append them after the new location "target". Of course, "end" must
* be after "start" and target must not be located withing this range. If you want to move something to the start of the list
* use null as value for target.<br>
* Any instruction targeters pointing to handles within the block, keep their targets.
*
* @param start of moved block
* @param end of moved block
* @param target of moved block
*/
public void move(InstructionHandle start, InstructionHandle end, InstructionHandle target) {
// Step 1: Check constraints
if (start == null || end == null) {
throw new ClassGenException("Invalid null handle: From " + start + " to " + end);
}
if (target == start || target == end) {
throw new ClassGenException("Invalid range: From " + start + " to " + end + " contains target " + target);
}
for (InstructionHandle ih = start; ih != end.next; ih = ih.next) {
if (ih == null) {
throw new ClassGenException("Invalid range: From " + start + " to " + end);
} else if (ih == target) {
throw new ClassGenException("Invalid range: From " + start + " to " + end + " contains target " + target);
}
}
// Step 2: Temporarily remove the given instructions from the list
InstructionHandle prev = start.prev, next = end.next;
if (prev != null) {
prev.next = next;
} else {
this.start = next;
}
if (next != null) {
next.prev = prev;
} else {
this.end = prev;
}
start.prev = end.next = null;
// Step 3: append after target
if (target == null) { // append to start of list
end.next = this.start;
this.start = start;
} else {
next = target.next;
target.next = start;
start.prev = target;
end.next = next;
if (next != null) {
next.prev = end;
}
}
}
/**
* Move a single instruction (handle) to a new location.
*
* @param ih moved instruction
* @param target new location of moved instruction
*/
public void move(InstructionHandle ih, InstructionHandle target) {
move(ih, ih, target);
}
/**
* Remove from instruction 'prev' to instruction 'next' both contained in this list.
*
* If careAboutLostTargeters is true then this method will throw a TargetLostException when one of the removed instruction
* handles is still being targeted.
*
* @param prev where to start deleting (predecessor, exclusive)
* @param next where to end deleting (successor, exclusive)
*/
private void remove(InstructionHandle prev, InstructionHandle next, boolean careAboutLostTargeters) throws TargetLostException {
InstructionHandle first, last; // First and last deleted instruction
if (prev == null && next == null) { // singleton list
first = last = start;
start = end = null;
} else {
if (prev == null) { // At start of list
first = start;
start = next;
} else {
first = prev.next;
prev.next = next;
}
if (next == null) { // At end of list
last = end;
end = prev;
} else {
last = next.prev;
next.prev = prev;
}
}
first.prev = null; // Completely separated from rest of list
last.next = null;
if (!careAboutLostTargeters) {
return;
}
List<InstructionHandle> target_vec = new ArrayList<>();
for (InstructionHandle ih = first; ih != null; ih = ih.next) {
ih.getInstruction().dispose(); // e.g. BranchInstructions release their targets
}
StringBuilder buf = new StringBuilder("{ ");
for (InstructionHandle ih = first; ih != null; ih = next) {
next = ih.next;
length--;
Set<InstructionTargeter> targeters = ih.getTargeters();
boolean isOK = false;
for (InstructionTargeter instructionTargeter : targeters) {
if (instructionTargeter.getClass().getName().endsWith("ShadowRange")
|| instructionTargeter.getClass().getName().endsWith("ExceptionRange")
|| instructionTargeter.getClass().getName().endsWith("LineNumberTag")) {
isOK = true;
} else {
System.out.println(instructionTargeter.getClass());
}
}
if (!isOK) {
target_vec.add(ih);
buf.append(ih.toString(true) + " ");
ih.next = ih.prev = null;
} else {
ih.dispose();
}
// if (ih.hasTargeters()) { // Still got targeters?
// InstructionTargeter[] targeters = ih.getTargeters();
// boolean isOK = false;
// for (int i = 0; i < targeters.length; i++) {
// InstructionTargeter instructionTargeter = targeters[i];
// if (instructionTargeter.getClass().getName().endsWith("ShadowRange")
// || instructionTargeter.getClass().getName().endsWith("ExceptionRange")
// || instructionTargeter.getClass().getName().endsWith("LineNumberTag")) {
// isOK = true;
// } else {
// System.out.println(instructionTargeter.getClass());
// }
// }
// if (!isOK) {
// target_vec.add(ih);
// buf.append(ih.toString(true) + " ");
// ih.next = ih.prev = null;
// } else {
// ih.dispose();
// }
// } else {
// ih.dispose();
// }
}
buf.append("}");
if (!target_vec.isEmpty()) {
InstructionHandle[] targeted = new InstructionHandle[target_vec.size()];
target_vec.toArray(targeted);
throw new TargetLostException(targeted, buf.toString());
}
}
/**
* Remove instruction from this list. The corresponding Instruction handles must not be reused!
*
* @param ih instruction (handle) to remove
*/
public void delete(InstructionHandle ih) throws TargetLostException {
remove(ih.prev, ih.next, false);
}
/**
* Remove instruction from this list. The corresponding Instruction handles must not be reused!
*
* @param i instruction to remove
*/
// public void delete(Instruction i) throws TargetLostException {
// InstructionHandle ih;
//
// if((ih = findInstruction1(i)) == null)
// throw new ClassGenException("Instruction " + i +
// " is not contained in this list.");
// delete(ih);
// }
/**
* Remove instructions from instruction `from' to instruction `to' contained in this list. The user must ensure that `from' is
* an instruction before `to', or risk havoc. The corresponding Instruction handles must not be reused!
*
* @param from where to start deleting (inclusive)
* @param to where to end deleting (inclusive)
*/
public void delete(InstructionHandle from, InstructionHandle to) throws TargetLostException {
remove(from.prev, to.next, false);
}
/**
* Remove instructions from instruction `from' to instruction `to' contained in this list. The user must ensure that `from' is
* an instruction before `to', or risk havoc. The corresponding Instruction handles must not be reused!
*
* @param from where to start deleting (inclusive)
* @param to where to end deleting (inclusive)
*/
public void delete(Instruction from, Instruction to) throws TargetLostException {
InstructionHandle from_ih, to_ih;
if ((from_ih = findInstruction1(from)) == null) {
throw new ClassGenException("Instruction " + from + " is not contained in this list.");
}
if ((to_ih = findInstruction2(to)) == null) {
throw new ClassGenException("Instruction " + to + " is not contained in this list.");
}
delete(from_ih, to_ih);
}
/**
* Search for given Instruction reference, start at beginning of list.
*
* @param i instruction to search for
* @return instruction found on success, null otherwise
*/
private InstructionHandle findInstruction1(Instruction i) {
for (InstructionHandle ih = start; ih != null; ih = ih.next) {
if (ih.instruction == i) {
return ih;
}
}
return null;
}
/**
* Search for given Instruction reference, start at end of list
*
* @param i instruction to search for
* @return instruction found on success, null otherwise
*/
private InstructionHandle findInstruction2(Instruction i) {
for (InstructionHandle ih = end; ih != null; ih = ih.prev) {
if (ih.instruction == i) {
return ih;
}
}
return null;
}
public boolean contains(InstructionHandle i) {
if (i == null) {
return false;
}
for (InstructionHandle ih = start; ih != null; ih = ih.next) {
if (ih == i) {
return true;
}
}
return false;
}
public boolean contains(Instruction i) {
return findInstruction1(i) != null;
}
public void setPositions() {
setPositions(false);
}
/**
* Give all instructions their position number (offset in byte stream), i.e., make the list ready to be dumped.
*
* @param check Perform sanity checks, e.g. if all targeted instructions really belong to this list
*/
public void setPositions(boolean check) {
int maxAdditionalBytes = 0;
int index = 0, count = 0;
int[] pos = new int[length];
// Pass 0: Sanity checks
if (check) {
checkInstructionList();
}
// Pass 1: Set position numbers and sum up the maximum number of bytes an
// instruction may be shifted.
for (InstructionHandle ih = start; ih != null; ih = ih.next) {
Instruction i = ih.instruction;
ih.setPosition(index);
pos[count++] = index;
/*
* Get an estimate about how many additional bytes may be added, because BranchInstructions may have variable length
* depending on the target offset (short vs. int) or alignment issues (TABLESWITCH and LOOKUPSWITCH).
*/
switch (i.opcode) {
case Constants.JSR:
case Constants.GOTO:
maxAdditionalBytes += 2;
break;
case Constants.TABLESWITCH:
case Constants.LOOKUPSWITCH:
maxAdditionalBytes += 3;
break;
}
index += i.getLength();
}
// OPTIMIZE positions will only move around if there have been expanding instructions
// if (max_additional_bytes==0...) {
//
// }
/*
* Pass 2: Expand the variable-length (Branch)Instructions depending on the target offset (short or int) and ensure that
* branch targets are within this list.
*/
boolean nonZeroOffset = false;
int offset = 0;
for (InstructionHandle ih = start; ih != null; ih = ih.next) {
if (ih instanceof BranchHandle) {
offset += ((BranchHandle) ih).updatePosition(offset, maxAdditionalBytes);
if (offset != 0) {
nonZeroOffset = true;
}
}
}
if (nonZeroOffset) {
/*
* Pass 3: Update position numbers (which may have changed due to the preceding expansions), like pass 1.
*/
index = count = 0;
for (InstructionHandle ih = start; ih != null; ih = ih.next) {
Instruction i = ih.instruction;
ih.setPosition(index);
pos[count++] = index;
index += i.getLength();
}
}
positions = new int[count]; // Trim to proper size
System.arraycopy(pos, 0, positions, 0, count);
}
private void checkInstructionList() {
for (InstructionHandle ih = start; ih != null; ih = ih.next) {
Instruction i = ih.instruction;
if (i instanceof InstructionBranch) { // target instruction within list?
Instruction inst = ((InstructionBranch) i).getTarget().instruction;
if (!contains(inst)) {
throw new ClassGenException("Branch target of " + Constants.OPCODE_NAMES[i.opcode] + ":" + inst
+ " not in instruction list");
}
if (i instanceof InstructionSelect) {
InstructionHandle[] targets = ((InstructionSelect) i).getTargets();
for (InstructionHandle target : targets) {
inst = target.instruction;
if (!contains(inst)) {
throw new ClassGenException("Branch target of " + Constants.OPCODE_NAMES[i.opcode] + ":" + inst
+ " not in instruction list");
}
}
}
if (!(ih instanceof BranchHandle)) {
throw new ClassGenException("Branch instruction " + Constants.OPCODE_NAMES[i.opcode] + ":" + inst
+ " not contained in BranchHandle.");
}
}
}
}
/**
* When everything is finished, use this method to convert the instruction list into an array of bytes.
*
* @return the byte code ready to be dumped
*/
public byte[] getByteCode() {
// Update position indices of instructions
setPositions();
ByteArrayOutputStream b = new ByteArrayOutputStream();
DataOutputStream out = new DataOutputStream(b);
try {
for (InstructionHandle ih = start; ih != null; ih = ih.next) {
Instruction i = ih.instruction;
i.dump(out); // Traverse list
}
} catch (IOException e) {
System.err.println(e);
return null;
}
byte[] byteCode = b.toByteArray();
if (byteCode.length > Constants.MAX_CODE_SIZE) {
throw new ClassGenException("Code size too big: " + byteCode.length);
}
return byteCode;
}
/**
* @return an array of instructions without target information for branch instructions.
*/
public Instruction[] getInstructions() {
ByteSequence bytes = new ByteSequence(getByteCode());
List<Instruction> instructions = new ArrayList<>();
try {
while (bytes.available() > 0) {
instructions.add(Instruction.readInstruction(bytes));
}
} catch (IOException e) {
throw new ClassGenException(e.toString());
}
Instruction[] result = new Instruction[instructions.size()];
instructions.toArray(result);
return result;
}
@Override
public String toString() {
return toString(true);
}
/**
* @param verbose toggle output format
* @return String containing all instructions in this list.
*/
public String toString(boolean verbose) {
StringBuilder buf = new StringBuilder();
for (InstructionHandle ih = start; ih != null; ih = ih.next) {
buf.append(ih.toString(verbose) + "\n");
}
return buf.toString();
}
/**
* @return Enumeration that lists all instructions (handles)
*/
public Iterator iterator() {
return new Iterator() {
private InstructionHandle ih = start;
public Object next() {
InstructionHandle i = ih;
ih = ih.next;
return i;
}
public void remove() {
throw new UnsupportedOperationException();
}
public boolean hasNext() {
return ih != null;
}
};
}
/**
* @return array containing all instructions (handles)
*/
public InstructionHandle[] getInstructionHandles() {
InstructionHandle[] ihs = new InstructionHandle[length];
InstructionHandle ih = start;
for (int i = 0; i < length; i++) {
ihs[i] = ih;
ih = ih.next;
}
return ihs;
}
/**
* Get positions (offsets) of all instructions in the list. This relies on that the list has been freshly created from an byte
* code array, or that setPositions() has been called. Otherwise this may be inaccurate.
*
* @return array containing all instruction's offset in byte code
*/
public int[] getInstructionPositions() {
return positions;
}
/**
* @return complete, i.e., deep copy of this list
*/
public InstructionList copy() {
HashMap<InstructionHandle, InstructionHandle> map = new HashMap<>();
InstructionList il = new InstructionList();
/*
* Pass 1: Make copies of all instructions, append them to the new list and associate old instruction references with the
* new ones, i.e., a 1:1 mapping.
*/
for (InstructionHandle ih = start; ih != null; ih = ih.next) {
Instruction i = ih.instruction;
Instruction c = i.copy(); // Use clone for shallow copy
if (c instanceof InstructionBranch) {
map.put(ih, il.append((InstructionBranch) c));
} else {
map.put(ih, il.append(c));
}
}
/*
* Pass 2: Update branch targets.
*/
InstructionHandle ih = start;
InstructionHandle ch = il.start;
while (ih != null) {
Instruction i = ih.instruction;
Instruction c = ch.instruction;
if (i instanceof InstructionBranch) {
InstructionBranch bi = (InstructionBranch) i;
InstructionBranch bc = (InstructionBranch) c;
InstructionHandle itarget = bi.getTarget(); // old target
// New target is in hash map
bc.setTarget(map.get(itarget));
if (bi instanceof InstructionSelect) { // Either LOOKUPSWITCH or TABLESWITCH
InstructionHandle[] itargets = ((InstructionSelect) bi).getTargets();
InstructionHandle[] ctargets = ((InstructionSelect) bc).getTargets();
for (int j = 0; j < itargets.length; j++) { // Update all targets
ctargets[j] = map.get(itargets[j]);
}
}
}
ih = ih.next;
ch = ch.next;
}
return il;
}
/**
* Replace all references to the old constant pool with references to the new constant pool
*/
public void replaceConstantPool(ConstantPool old_cp, ConstantPool new_cp) {
for (InstructionHandle ih = start; ih != null; ih = ih.next) {
Instruction i = ih.instruction;
if (i.isConstantPoolInstruction()) {
InstructionCP ci = (InstructionCP) i;
Constant c = old_cp.getConstant(ci.getIndex());
ci.setIndex(new_cp.addConstant(c, old_cp));
}
}
}
private void clear() {
start = end = null;
length = 0;
}
/**
* Delete contents of list. Provides better memory utilization, because the system then may reuse the instruction handles. This
* method is typically called right after <href="MethodGen.html#getMethod()">MethodGen.getMethod()</a>.
*/
public void dispose() {
// Traverse in reverse order, because ih.next is overwritten
for (InstructionHandle ih = end; ih != null; ih = ih.prev) {
/*
* Causes BranchInstructions to release target and targeters, because it calls dispose() on the contained instruction.
*/
ih.dispose();
}
clear();
}
/**
* @return start of list
*/
public InstructionHandle getStart() {
return start;
}
/**
* @return end of list
*/
public InstructionHandle getEnd() {
return end;
}
/**
* @return length of list (Number of instructions, not bytes)
*/
public int getLength() {
return length;
}
/**
* @return length of list (Number of instructions, not bytes)
*/
public int size() {
return length;
}
/**
* Redirect all references from old_target to new_target, i.e., update targets of branch instructions.
*
* @param old_target the old target instruction handle
* @param new_target the new target instruction handle
*/
public void redirectBranches(InstructionHandle old_target, InstructionHandle new_target) {
for (InstructionHandle ih = start; ih != null; ih = ih.next) {
Instruction i = ih.getInstruction();
if (i instanceof InstructionBranch) {
InstructionBranch b = (InstructionBranch) i;
InstructionHandle target = b.getTarget();
if (target == old_target) {
b.setTarget(new_target);
}
if (b instanceof InstructionSelect) { // Either LOOKUPSWITCH or TABLESWITCH
InstructionHandle[] targets = ((InstructionSelect) b).getTargets();
for (int j = 0; j < targets.length; j++) {
if (targets[j] == old_target) {
((InstructionSelect) b).setTarget(j, new_target);
}
}
}
}
}
}
/**
* Redirect all references of local variables from old_target to new_target.
*
* @param lg array of local variables
* @param old_target the old target instruction handle
* @param new_target the new target instruction handle
* @see MethodGen
*/
public void redirectLocalVariables(LocalVariableGen[] lg, InstructionHandle old_target, InstructionHandle new_target) {
for (LocalVariableGen localVariableGen : lg) {
InstructionHandle start = localVariableGen.getStart();
InstructionHandle end = localVariableGen.getEnd();
if (start == old_target) {
localVariableGen.setStart(new_target);
}
if (end == old_target) {
localVariableGen.setEnd(new_target);
}
}
}
/**
* Redirect all references of exception handlers from old_target to new_target.
*
* @param exceptions array of exception handlers
* @param old_target the old target instruction handle
* @param new_target the new target instruction handle
* @see MethodGen
*/
public void redirectExceptionHandlers(CodeExceptionGen[] exceptions, InstructionHandle old_target, InstructionHandle new_target) {
for (CodeExceptionGen exception : exceptions) {
if (exception.getStartPC() == old_target) {
exception.setStartPC(new_target);
}
if (exception.getEndPC() == old_target) {
exception.setEndPC(new_target);
}
if (exception.getHandlerPC() == old_target) {
exception.setHandlerPC(new_target);
}
}
}
}