7033660: Update copyright year to 2011 on any files changed in 2011
Reviewed-by: dholmes
/*
* Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code 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 Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/*
* An extension of BinaryCode that allows code to be printed.
* Includes printing of disassembled byte codes, exception info,
* local variable and line number info.
*
*/
package ilib;
import java.io.ByteArrayInputStream;
import java.io.CharArrayWriter;
import java.io.DataInputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.PrintStream;
import java.util.Map;
import java.util.HashMap;
class InjectBytecodes implements RuntimeConstants {
private final ClassReaderWriter c;
private final PrintStream output;
private final int length;
private final int[] map;
private final byte[] widening;
private final Injector[] before = new Injector[256];
private final Injector[] after = new Injector[256];
private final String className;
private final String methodName;
private final Map<Integer,byte[]> snippets = new HashMap<>();
private int pos;
private int newPos;
private class Span {
final int delta;
final int target;
final int newDelta;
final int newTarget;
Span(int delta) {
this.delta = delta;
this.target = pos + delta;
this.newTarget = map[target];
this.newDelta = newTarget - newPos;
}
}
/**
* Constructor
*/
InjectBytecodes(ClassReaderWriter c, int length,
String className, String methodName) {
this.c = c;
this.output = System.out;
this.length = length;
this.map = new int[length + 1];
this.widening = new byte[length + 1];
this.className = className;
this.methodName = methodName;
c.markLocalPositionStart();
for (int i = 0; i <= length; ++i) {
map[i] = i;
}
}
public void inject(int at, byte[] newCode) {
snippets.put(new Integer(at), newCode);
trace("external ");
inject(at, newCode.length);
}
private void inject(int at, int len) {
if (Inject.verbose) {
traceln("Injecting " + len + " at " + at);
}
for (int i = at; i <= length; ++i) {
map[i] += len;
}
}
private void widen(int at, int len) {
int delta = len - widening[at];
if (Inject.verbose) {
traceln();
traceln("Widening to " + len + " at " + at);
}
inject(c.localPosition(), delta); // inject at end of instruction
widening[at] = (byte)len; // mark at beginning of instruction
}
public void injectBefore(int code, Injector inj) {
before[code] = inj;
}
public void injectAfter(int code, Injector inj) {
after[code] = inj;
}
private void trace(String str) {
if (Inject.verbose) {
output.print(str);
}
}
private void traceln(String str) {
if (Inject.verbose) {
output.println(str);
}
}
private void traceln() {
if (Inject.verbose) {
output.println();
}
}
private void trace(int i) {
if (Inject.verbose) {
output.print(i);
}
}
/**
* Print an integer so that it takes 'length' characters in
* the output. Temporary until formatting code is stable.
*/
private void traceFixedWidthInt(int x, int length) {
if (Inject.verbose) {
CharArrayWriter baStream = new CharArrayWriter();
PrintWriter pStream = new PrintWriter(baStream);
pStream.print(x);
String str = baStream.toString();
for (int cnt = length - str.length(); cnt > 0; --cnt)
trace(" ");
trace(str);
}
}
void adjustOffsets() throws IOException {
if (Inject.verbose) {
traceln();
traceln("Method " + methodName);
traceln();
}
c.rewind();
while (c.localPosition() < length) {
insertAtInstruction();
}
trace("Searching for adjustments...");
c.rewind();
while (c.localPosition() < length) {
if (!adjustInstruction()) {
c.rewind();
traceln();
traceln("Restarting adjustments after change...");
}
}
// write the new bytecodes
traceln();
traceln();
trace("Writing new code...");
c.rewind();
while (c.localPosition() < length) {
writeInstruction();
}
if (!snippets.isEmpty()) {
throw new Error("not all snippets written");
}
}
/**
* Walk one instruction inserting instrumentation at specified instructions
*/
private void insertAtInstruction() throws IOException {
pos = c.localPosition();
int opcode = c.readU1();
if (opcode == opc_wide) {
// no support for instrumenting wide instructions
int wopcode = c.readU1();
int lvIndex = c.readU2();
switch (wopcode) {
case opc_aload: case opc_astore:
case opc_fload: case opc_fstore:
case opc_iload: case opc_istore:
case opc_lload: case opc_lstore:
case opc_dload: case opc_dstore:
case opc_ret:
break;
case opc_iinc:
c.readS2();
break;
default:
throw new Error("Invalid wide opcode: " + wopcode);
}
} else {
Injector inj;
inj = before[opcode];
if (inj != null) {
inject(pos, inj.bytecodes(className, methodName, pos));
}
switch (opcode) {
case opc_tableswitch:{
int header = (pos+1+3) & (~3); // 4byte boundry
c.skip(header - (pos+1)); // skip old padding
c.readU4();
int low = c.readU4();
int high = c.readU4();
c.skip((high+1-low) * 4);
break;
}
case opc_lookupswitch:{
int header = (pos+1+3) & (~3); // 4byte boundry
c.skip(header - (pos+1)); // skip padding
c.readU4();
int npairs = c.readU4();
c.skip(npairs * 8);
break;
}
default: {
int instrLen = opcLengths[opcode];
c.skip(instrLen-1);
}
}
inj = after[opcode];
if (inj != null) {
pos = c.localPosition();
inject(pos, inj.bytecodes(className, methodName, pos));
}
}
}
/**
* Walk one instruction adjusting for insertions
*/
private boolean adjustInstruction() throws IOException {
pos = c.localPosition();
newPos = map[pos];
int opcode = c.readU1();
if (Inject.verbose) {
traceln();
traceFixedWidthInt(pos, 4);
traceFixedWidthInt(newPos, 4);
trace(" ");
}
if (opcode == opc_wide) {
int wopcode = c.readU1();
int lvIndex = c.readU2();
if (Inject.verbose) {
trace(opcNames[wopcode] + "_w ");
}
switch (wopcode) {
case opc_aload: case opc_astore:
case opc_fload: case opc_fstore:
case opc_iload: case opc_istore:
case opc_lload: case opc_lstore:
case opc_dload: case opc_dstore:
case opc_ret:
trace(lvIndex);
break;
case opc_iinc:
int constVal = c.readS2();
if (Inject.verbose) {
trace(lvIndex + " " + constVal);
}
break;
default:
throw new Error("Invalid wide opcode: " + wopcode);
}
} else {
if (Inject.verbose) {
trace(opcNames[opcode]);
}
switch (opcode) {
case opc_tableswitch:{
int widened = widening[pos];
int header = (pos+1+3) & (~3); // 4byte boundry
int newHeader = (newPos+1+3) & (~3); // 4byte boundry
c.skip(header - (pos+1)); // skip old padding
Span defaultSkip = new Span(c.readU4());
int low = c.readU4();
int high = c.readU4();
if (Inject.verbose) {
trace(" " + low + " to " + high);
trace(": default= [was] " + defaultSkip.target);
trace(" [now] " + defaultSkip.newTarget);
for (int i = low; i <= high; ++i) {
Span jump = new Span(c.readU4());
traceln("");
trace('\t');
traceFixedWidthInt(i, 5);
trace(": " + jump.newTarget);
}
} else {
c.skip((high+1-low) * 4);
}
int newPadding = newHeader - newPos;
int oldPadding = header - pos;
int deltaPadding = newPadding - oldPadding;
if (widened != deltaPadding) {
widen(pos, deltaPadding);
return false; // cause restart
}
break;
}
case opc_lookupswitch:{
int widened = widening[pos];
int header = (pos+1+3) & (~3); // 4byte boundry
int newHeader = (newPos+1+3) & (~3); // 4byte boundry
c.skip(header - (pos+1)); // skip old padding
Span defaultSkip = new Span(c.readU4());
int npairs = c.readU4();
if (Inject.verbose) {
trace(" npairs: " + npairs);
trace(": default= [was] " + defaultSkip.target);
trace(" [now] " + defaultSkip.newTarget);
for (int i = 0; i< npairs; ++i) {
int match = c.readU4();
Span jump = new Span(c.readU4());
traceln("");
trace('\t');
traceFixedWidthInt(match, 5);
trace(": " + jump.newTarget);
}
} else {
c.skip(npairs * 8);
}
int newPadding = newHeader - newPos;
int oldPadding = header - pos;
int deltaPadding = newPadding - oldPadding;
if (widened != deltaPadding) {
widen(pos, deltaPadding);
return false; // cause restart
}
break;
}
case opc_jsr: case opc_goto:
case opc_ifeq: case opc_ifge: case opc_ifgt:
case opc_ifle: case opc_iflt: case opc_ifne:
case opc_if_icmpeq: case opc_if_icmpne: case opc_if_icmpge:
case opc_if_icmpgt: case opc_if_icmple: case opc_if_icmplt:
case opc_if_acmpeq: case opc_if_acmpne:
case opc_ifnull: case opc_ifnonnull: {
int widened = widening[pos];
Span jump = new Span(c.readS2());
if (widened == 0) { // not yet widened
int newDelta = jump.newDelta;
if ((newDelta < -32768) || (newDelta > 32767)) {
switch (opcode) {
case opc_jsr: case opc_goto:
widen(pos, 2); // will convert to wide
break;
default:
widen(pos, 5); // will inject goto_w
break;
}
return false; // cause restart
}
}
if (Inject.verbose) {
trace(" [was] " + jump.target + " ==> " +
" [now] " + jump.newTarget);
}
break;
}
case opc_jsr_w:
case opc_goto_w: {
Span jump = new Span(c.readU4());
if (Inject.verbose) {
trace(" [was] " + jump.target +
" [now] " + jump.newTarget);
}
break;
}
default: {
int instrLen = opcLengths[opcode];
c.skip(instrLen-1);
break;
}
}
}
return true; // successful return
}
/**
* Walk one instruction writing the transformed instruction.
*/
private void writeInstruction() throws IOException {
pos = c.localPosition();
newPos = map[pos];
byte[] newCode = snippets.remove(new Integer(pos));
if (newCode != null) {
traceln();
traceFixedWidthInt(pos, 4);
trace(" ... -- Inserting new code");
c.writeBytes(newCode);
}
int opcode = c.readU1();
if (Inject.verbose) {
traceln();
traceFixedWidthInt(pos, 4);
traceFixedWidthInt(newPos, 4);
trace(" ");
}
if (opcode == opc_wide) {
int wopcode = c.readU1();
int lvIndex = c.readU2();
if (Inject.verbose) {
trace(opcNames[wopcode] + "_w ");
}
c.writeU1(opcode);
c.writeU1(wopcode);
c.writeU2(lvIndex);
switch (wopcode) {
case opc_aload: case opc_astore:
case opc_fload: case opc_fstore:
case opc_iload: case opc_istore:
case opc_lload: case opc_lstore:
case opc_dload: case opc_dstore:
case opc_ret:
trace(lvIndex);
break;
case opc_iinc:
int constVal = c.readS2();
c.writeU2(constVal); // ??? U vs S
if (Inject.verbose) {
trace(lvIndex + " " + constVal);
}
break;
default:
throw new Error("Invalid wide opcode: " + wopcode);
}
} else {
if (Inject.verbose) {
trace(opcNames[opcode]);
}
switch (opcode) {
case opc_tableswitch:{
int header = (pos+1+3) & (~3); // 4byte boundry
int newHeader = (newPos+1+3) & (~3); // 4byte boundry
c.skip(header - (pos+1)); // skip old padding
Span defaultSkip = new Span(c.readU4());
int low = c.readU4();
int high = c.readU4();
c.writeU1(opcode); // copy instruction
for (int i = newPos+1; i < newHeader; ++i) {
c.writeU1(0); // write new padding
}
c.writeU4(defaultSkip.newDelta);
c.writeU4(low);
c.writeU4(high);
if (Inject.verbose) {
trace(" " + low + " to " + high);
trace(": default= [was] " + defaultSkip.target);
trace(" [now] " + defaultSkip.newTarget);
}
for (int i = low; i <= high; ++i) {
Span jump = new Span(c.readU4());
c.writeU4(jump.newDelta);
if (Inject.verbose) {
traceln("");
trace('\t');
traceFixedWidthInt(i, 5);
trace(": " + jump.newTarget);
}
}
break;
}
case opc_lookupswitch:{
int header = (pos+1+3) & (~3); // 4byte boundry
int newHeader = (newPos+1+3) & (~3); // 4byte boundry
c.skip(header - (pos+1)); // skip old padding
Span defaultSkip = new Span(c.readU4());
int npairs = c.readU4();
if (Inject.verbose) {
trace(" npairs: " + npairs);
trace(": default= [was] " + defaultSkip.target);
trace(" [now] " + defaultSkip.newTarget);
}
c.writeU1(opcode); // copy instruction
for (int i = newPos+1; i < newHeader; ++i) {
c.writeU1(0); // write new padding
}
c.writeU4(defaultSkip.newDelta);
c.writeU4(npairs);
for (int i = 0; i< npairs; ++i) {
int match = c.readU4();
Span jump = new Span(c.readU4());
c.writeU4(match);
c.writeU4(jump.newDelta);
if (Inject.verbose) {
traceln("");
trace('\t');
traceFixedWidthInt(match, 5);
trace(": " + jump.newTarget);
}
}
break;
}
case opc_jsr: case opc_goto:
case opc_ifeq: case opc_ifge: case opc_ifgt:
case opc_ifle: case opc_iflt: case opc_ifne:
case opc_if_icmpeq: case opc_if_icmpne: case opc_if_icmpge:
case opc_if_icmpgt: case opc_if_icmple: case opc_if_icmplt:
case opc_if_acmpeq: case opc_if_acmpne:
case opc_ifnull: case opc_ifnonnull: {
int widened = widening[pos];
Span jump = new Span(c.readS2());
int newOpcode = opcode; // default to unchanged
if (widened == 0) { // not widened
c.writeU1(opcode); // rewrite instruction
c.writeU2(jump.newDelta);
} else if (widened == 2) { // wide form
switch (opcode) {
case opc_jsr:
newOpcode = opc_jsr_w;
break;
case opc_goto:
newOpcode = opc_jsr_w;
break;
default:
throw new Error("unexpected opcode: " +
opcode);
}
c.writeU1(newOpcode); // write wide instruction
c.writeU4(jump.newDelta); // write new and wide delta
} else if (widened == 5) { // insert goto_w
switch (opcode) {
case opc_ifeq:
newOpcode = opc_ifne;
break;
case opc_ifge:
newOpcode = opc_iflt;
break;
case opc_ifgt:
newOpcode = opc_ifle;
break;
case opc_ifle:
newOpcode = opc_ifgt;
break;
case opc_iflt:
newOpcode = opc_ifge;
break;
case opc_ifne:
newOpcode = opc_ifeq;
break;
case opc_if_icmpeq:
newOpcode = opc_if_icmpne;
break;
case opc_if_icmpne:
newOpcode = opc_if_icmpeq;
break;
case opc_if_icmpge:
newOpcode = opc_if_icmplt;
break;
case opc_if_icmpgt:
newOpcode = opc_if_icmple;
break;
case opc_if_icmple:
newOpcode = opc_if_icmpgt;
break;
case opc_if_icmplt:
newOpcode = opc_if_icmpge;
break;
case opc_if_acmpeq:
newOpcode = opc_if_acmpne;
break;
case opc_if_acmpne:
newOpcode = opc_if_acmpeq;
break;
case opc_ifnull:
newOpcode = opc_ifnonnull;
break;
case opc_ifnonnull:
newOpcode = opc_ifnull;
break;
default:
throw new Error("unexpected opcode: " +
opcode);
}
c.writeU1(newOpcode); // write inverse branch
c.writeU2(3 + 5); // beyond if and goto_w
c.writeU1(opc_goto_w);// add a goto_w
c.writeU4(jump.newDelta); // write new and wide delta
} else {
throw new Error("unexpected widening");
}
if (Inject.verbose) {
trace(" [was] " + jump.target + " ==> " +
opcNames[newOpcode] +
" [now] " + jump.newTarget);
}
break;
}
case opc_jsr_w:
case opc_goto_w: {
Span jump = new Span(c.readU4());
c.writeU1(opcode); // instruction itself
c.writeU4(jump.newDelta);
if (Inject.verbose) {
trace(" [was] " + jump.target +
" [now] " + jump.newTarget);
}
break;
}
default: {
int instrLen = opcLengths[opcode];
c.writeU1(opcode); // instruction itself
c.copy(instrLen-1);
}
}
}
}
/**
* Copy the exception table for this method code
*/
void copyExceptionTable() throws IOException {
int tableLength = c.copyU2(); // exception table len
if (tableLength > 0) {
traceln();
traceln("Exception table:");
traceln(" from:old/new to:old/new target:old/new type");
for (int tcnt = tableLength; tcnt > 0; --tcnt) {
int startPC = c.readU2();
int newStartPC = map[startPC];
c.writeU2(newStartPC);
int endPC = c.readU2();
int newEndPC = map[endPC];
c.writeU2(newEndPC);
int handlerPC = c.readU2();
int newHandlerPC = map[handlerPC];
c.writeU2(newHandlerPC);
int catchType = c.copyU2();
if (Inject.verbose) {
traceFixedWidthInt(startPC, 6);
traceFixedWidthInt(newStartPC, 6);
traceFixedWidthInt(endPC, 6);
traceFixedWidthInt(newEndPC, 6);
traceFixedWidthInt(handlerPC, 6);
traceFixedWidthInt(newHandlerPC, 6);
trace(" ");
if (catchType == 0)
traceln("any");
else {
traceln("" + catchType);
}
}
}
}
}
/**
* Copy the line number table for this method code
*/
void copyLineNumberAttr() throws IOException {
// name index already read
c.copy(4); // attr len
int tableLength = c.copyU2(); // line table len
if (tableLength > 0) {
if (Inject.verbose) {
traceln();
traceln("Line numbers for method " + methodName);
}
for (int tcnt = tableLength; tcnt > 0; --tcnt) {
int startPC = c.readU2();
int newStartPC = map[startPC];
c.writeU2(newStartPC);
int lineNumber = c.copyU2();
if (Inject.verbose) {
traceln(" line " + lineNumber +
": [was] " + startPC +
" [now] " + newStartPC);
}
}
}
}
/**
* Copy the local variable table for this method code
*/
void copyLocalVarAttr() throws IOException {
// name index already read
c.copy(4); // attr len
int tableLength = c.copyU2(); // local var table len
if (tableLength > 0) {
if (Inject.verbose) {
traceln();
traceln("Local variables for method " + methodName);
}
for (int tcnt = tableLength; tcnt > 0; --tcnt) {
int startPC = c.readU2();
int newStartPC = map[startPC];
c.writeU2(newStartPC);
int length = c.readU2();
int endPC = startPC + length;
int newEndPC = map[endPC];
int newLength = newEndPC - newStartPC;
c.writeU2(newLength);
int nameIndex = c.copyU2();
int descriptorIndex = c.copyU2();
int index = c.copyU2();
if (Inject.verbose) {
trace(" ");
trace(descriptorIndex);
trace(" ");
trace(nameIndex);
traceln(" pc= [was] " + startPC + " [now] " + newStartPC +
", length= [was] " + length + " [now] " + newLength +
", slot=" + index);
}
}
}
}
}