/*
* Copyright 2010-2012 VMware and contributors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springsource.loaded;
import java.io.ByteArrayInputStream;
import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
// TODO try to recall why I created ConstantPoolChecker2, what was up with ConstantPoolChecker?
// http://java.sun.com/docs/books/jvms/second_edition/html/ClassFile.doc.html
/**
* Enables us to check things quickly in the constant pool. This version accumulates the class references and the method references,
* for classes that start with 'j' (we want to catch: java/lang). It skips everything it can and the end result is a list of class
* references and a list of method references. The former look like this 'a/b/C' whilst the latter look like this
* 'java/lang/Foo.bar' (the descriptor for the method is not included). Interface methods are skipped.
*
* @author Andy Clement
* @since 0.7.3
*/
public class ConstantPoolChecker2 {
private static final boolean DEBUG = false;
private final static byte CONSTANT_Utf8 = 1;
private final static byte CONSTANT_Integer = 3;
private final static byte CONSTANT_Float = 4;
private final static byte CONSTANT_Long = 5;
private final static byte CONSTANT_Double = 6;
private final static byte CONSTANT_Class = 7;
private final static byte CONSTANT_String = 8;
private final static byte CONSTANT_Fieldref = 9;
private final static byte CONSTANT_Methodref = 10;
private final static byte CONSTANT_InterfaceMethodref = 11;
private final static byte CONSTANT_NameAndType = 12;
// Test entry point just goes through all the code in the bin folder
public static void main(String[] args) throws Exception {
File[] fs = new File("./bin").listFiles();
// File[] fs = new File("../testdata-groovy/bin").listFiles();
// File[] fs = new File("/Users/aclement/grailsreload/foo/target/classes").listFiles();
checkThemAll(fs);
System.out.println("total=" + total / 1000000d);
}
private static void checkThemAll(File[] fs) throws Exception {
for (File f : fs) {
if (f.isDirectory()) {
checkThemAll(f.listFiles());
} else if (f.getName().endsWith(".class")) {
System.out.println(f);
byte[] data = Utils.loadFromStream(new FileInputStream(f));
long stime = System.nanoTime();
References refs = getReferences(data);
total += (System.nanoTime() - stime);
System.out.println(refs.referencedClasses);
System.out.println(refs.referencedMethods);
}
}
}
static long total = 0;
// ClassFile {
// u4 magic;
// u2 minor_version;
// u2 major_version;
// u2 constant_pool_count;
// cp_info constant_pool[constant_pool_count-1];
// u2 access_flags;
// u2 this_class;
// u2 super_class;
// u2 interfaces_count;
// u2 interfaces[interfaces_count];
// u2 fields_count;
// field_info fields[fields_count];
// u2 methods_count;
// method_info methods[methods_count];
// u2 attributes_count;
// attribute_info attributes[attributes_count];
// }
static References getReferences(byte[] bytes) {
ConstantPoolChecker2 cpc2 = new ConstantPoolChecker2(bytes);
return new References(cpc2.slashedclassname, cpc2.referencedClasses, cpc2.referencedMethods);
}
static class References {
String slashedClassName;
List<String> referencedClasses;
List<String> referencedMethods;
References(String slashedClassName, List<String> rc, List<String> rm) {
this.slashedClassName = slashedClassName;
this.referencedClasses = rc;
this.referencedMethods = rm;
}
}
// Filled with strings and int[]
private Object[] cpdata;
private int cpsize;
private int[] type;
// Does not need to be a set as there are no dups in the ConstantPool (for a class from a decent compiler...)
private List<String> referencedClasses = new ArrayList<String>();
private List<String> referencedMethods = new ArrayList<String>();
private String slashedclassname;
private ConstantPoolChecker2(byte[] bytes) {
readConstantPool(bytes);
computeReferences();
}
public void computeReferences() {
for (int i = 0; i < cpsize; i++) {
switch (type[i]) {
case CONSTANT_Class:
int classindex = ((Integer) cpdata[i]);
String classname = (String) cpdata[classindex];
if (classname == null) {
throw new IllegalStateException();
}
referencedClasses.add(classname);
break;
case CONSTANT_Methodref:
int[] indexes = (int[]) cpdata[i];
int classindex2 = indexes[0];
int nameAndTypeIndex = indexes[1];
StringBuilder s = new StringBuilder();
String theClassName = (String) cpdata[(Integer) cpdata[classindex2]];
if (theClassName.charAt(0) == 'j') {
s.append(theClassName);
s.append(".");
s.append((String) cpdata[(Integer) cpdata[nameAndTypeIndex]]);
referencedMethods.add(s.toString());
}
break;
// private final static byte CONSTANT_Utf8 = 1;
// private final static byte CONSTANT_Integer = 3;
// private final static byte CONSTANT_Float = 4;
// private final static byte CONSTANT_Long = 5;
// private final static byte CONSTANT_Double = 6;
// private final static byte CONSTANT_String = 8;
// private final static byte CONSTANT_Fieldref = 9;
// private final static byte CONSTANT_InterfaceMethodref = 11;
// private final static byte CONSTANT_NameAndType = 12;
}
}
}
public void readConstantPool(byte[] bytes) {
try {
ByteArrayInputStream bais = new ByteArrayInputStream(bytes);
DataInputStream dis = new DataInputStream(bais);
int magic = dis.readInt(); // magic 0xCAFEBABE
if (magic != 0xCAFEBABE) {
throw new IllegalStateException("not bytecode, magic was 0x" + Integer.toString(magic, 16));
}
dis.skip(4); // skip minor and major versions
cpsize = dis.readShort();
if (DEBUG) {
System.out.println("Constant Pool Size =" + cpsize);
}
cpdata = new Object[cpsize];
type = new int[cpsize];
for (int cpentry = 1; cpentry < cpsize; cpentry++) {
boolean doubleSlot = processConstantPoolEntry(cpentry, dis);
if (doubleSlot) {
cpentry++;
}
}
dis.skip(2); // access flags
int thisclassname = dis.readShort();
int classindex = ((Integer) cpdata[thisclassname]);
slashedclassname = (String) cpdata[classindex];
} catch (Exception e) {
throw new IllegalStateException("Unexpected problem processing bytes for class", e);
}
}
private boolean processConstantPoolEntry(int index, DataInputStream dis) throws IOException {
byte b = dis.readByte();
switch (b) {
case CONSTANT_Utf8:
// CONSTANT_Utf8_info { u1 tag; u2 length; u1 bytes[length]; }
cpdata[index] = dis.readUTF();
// type[index] = b;
if (DEBUG) {
System.out.println(index + ":UTF8[" + cpdata[index] + "]");
}
break;
case CONSTANT_Integer:
// CONSTANT_Integer_info { u1 tag; u4 bytes; }
if (DEBUG) {
int i = dis.readInt();
if (DEBUG) {
System.out.println(index + ":INTEGER[" + i + "]");
}
} else {
dis.skip(4);
}
break;
case CONSTANT_Float:
// CONSTANT_Float_info { u1 tag; u4 bytes; }
if (DEBUG) {
float f = dis.readFloat();
if (DEBUG) {
System.out.println(index + ":FLOAT[" + f + "]");
}
} else {
dis.skip(4);
}
break;
case CONSTANT_Long:
// CONSTANT_Long_info {
// u1 tag;
// u4 high_bytes;
// u4 low_bytes;
// }
if (DEBUG) {
long l = dis.readLong();
if (DEBUG) {
System.out.println(index + ":LONG[" + l + "]");
}
} else {
dis.skip(8);
}
return true;
case CONSTANT_Double:
// CONSTANT_Double_info {
// u1 tag;
// u4 high_bytes;
// u4 low_bytes;
// }
if (DEBUG) {
double d = dis.readDouble();
if (DEBUG) {
System.out.println(index + ":DOUBLE[" + d + "]");
}
} else {
dis.skip(8);
}
return true;
case CONSTANT_Class:
// CONSTANT_Class_info { u1 tag; u2 name_index; }
type[index] = b;
cpdata[index] = (int) dis.readShort();
if (DEBUG) {
System.out.println(index + ":CLASS[name_index=" + cpdata[index] + "]");
}
break;
case CONSTANT_String:
// CONSTANT_String_info { u1 tag; u2 string_index; }
if (DEBUG) {
cpdata[index] = (int) dis.readShort();
if (DEBUG) {
System.out.println(index + ":STRING[string_index=" + cpdata[index] + "]");
}
} else {
dis.skip(2);
}
break;
case CONSTANT_Fieldref:
// CONSTANT_Fieldref_info { u1 tag; u2 class_index; u2 name_and_type_index; }
if (DEBUG) {
cpdata[index] = new int[] { dis.readShort(), dis.readShort() };
if (DEBUG) {
System.out.println(index + ":FIELDREF[class_index=" + ((int[]) cpdata[index])[0] + ",name_and_type_index="
+ ((int[]) cpdata[index])[1] + "]");
}
} else {
dis.skip(4);
}
break;
case CONSTANT_Methodref:
// CONSTANT_Methodref_info { u1 tag; u2 class_index; u2 name_and_type_index; }
type[index] = b;
//if (DEBUG) {
cpdata[index] = new int[] { dis.readShort(), dis.readShort() };
if (DEBUG) {
System.out.println(index + ":METHODREF[class_index=" + ((int[]) cpdata[index])[0] + ",name_and_type_index="
+ ((int[]) cpdata[index])[1] + "]");
}
// } else {
// dis.skip(4);
// }
break;
case CONSTANT_InterfaceMethodref:
// CONSTANT_InterfaceMethodref_info {
// u1 tag;
// u2 class_index;
// u2 name_and_type_index;
// }
if (DEBUG) {
cpdata[index] = new int[] { dis.readShort(), dis.readShort() };
if (DEBUG) {
System.out.println(index + ":INTERFACEMETHODREF[class_index=" + ((int[]) cpdata[index])[0]
+ ",name_and_type_index=" + ((int[]) cpdata[index])[1] + "]");
}
} else {
dis.skip(4);
}
break;
case CONSTANT_NameAndType:
// The CONSTANT_NameAndType_info structure is used to represent a field or method, without indicating which class or interface type it belongs to:
// CONSTANT_NameAndType_info { u1 tag; u2 name_index; u2 descriptor_index; }
// type[index] = b;
cpdata[index] = (int) dis.readShort();// new int[] { dis.readShort(), dis.readShort() };
dis.skip(2); // skip the descriptor for now
if (DEBUG) {
System.out.println(index + ":NAMEANDTYPE[name_index=" + ((int[]) cpdata[index])[0] + ",descriptor_index="
+ ((int[]) cpdata[index])[1] + "]");
}
break;
default:
throw new IllegalStateException("Entry: " + index + " " + Byte.toString(b));
}
return false;
}
}