private StructureConstant createClassInfoStruct() {
int flags = 0;
if (Modifier.isPublic(sootClass.getModifiers())) {
flags |= CI_PUBLIC;
}
if (Modifier.isFinal(sootClass.getModifiers())) {
flags |= CI_FINAL;
}
if (Modifier.isInterface(sootClass.getModifiers())) {
flags |= CI_INTERFACE;
}
if (Modifier.isAbstract(sootClass.getModifiers())) {
flags |= CI_ABSTRACT;
}
if ((sootClass.getModifiers() & 0x1000) > 0) {
flags |= CI_SYNTHETIC;
}
if (Modifier.isAnnotation(sootClass.getModifiers())) {
flags |= CI_ANNOTATION;
}
if (Modifier.isEnum(sootClass.getModifiers())) {
flags |= CI_ENUM;
}
if (attributesEncoder.classHasAttributes()) {
flags |= CI_ATTRIBUTES;
}
if (hasFinalizer(sootClass)) {
flags |= CI_FINALIZABLE;
}
// Create the ClassInfoHeader structure.
StructureConstantBuilder header = new StructureConstantBuilder();
header.add(new NullConstant(I8_PTR)); // Points to the runtime Class struct
header.add(new IntegerConstant(flags));
header.add(getString(getInternalName(sootClass)));
if (sootClass.declaresMethod("<clinit>", Collections.emptyList(), VoidType.v())) {
SootMethod method = sootClass.getMethod("<clinit>", Collections.emptyList(), VoidType.v());
header.add(new FunctionRef(mangleMethod(method), getFunctionType(method)));
} else {
header.add(new NullConstant(I8_PTR));
}
header.add(sizeof(classType));
header.add(sizeof(instanceType));
if (!instanceFields.isEmpty()) {
header.add(offsetof(instanceType, 1, 1));
} else {
header.add(sizeof(instanceType));
}
header.add(new IntegerConstant((short) countReferences(classFields)));
header.add(new IntegerConstant((short) countReferences(instanceFields)));
PackedStructureConstantBuilder body = new PackedStructureConstantBuilder();
body.add(new IntegerConstant((short) sootClass.getInterfaceCount()));
body.add(new IntegerConstant((short) sootClass.getFieldCount()));
body.add(new IntegerConstant((short) sootClass.getMethodCount()));
if (!sootClass.isInterface()) {
body.add(
getStringOrNull(
sootClass.hasSuperclass() ? getInternalName(sootClass.getSuperclass()) : null));
}
if (attributesEncoder.classHasAttributes()) {
body.add(new ConstantBitcast(attributesEncoder.getClassAttributes().ref(), I8_PTR));
}
for (SootClass s : sootClass.getInterfaces()) {
body.add(getString(getInternalName(s)));
}
for (SootField f : sootClass.getFields()) {
flags = 0;
soot.Type t = f.getType();
if (t instanceof PrimType) {
if (t.equals(BooleanType.v())) {
flags |= DESC_Z;
} else if (t.equals(ByteType.v())) {
flags |= DESC_B;
} else if (t.equals(ShortType.v())) {
flags |= DESC_S;
} else if (t.equals(CharType.v())) {
flags |= DESC_C;
} else if (t.equals(IntType.v())) {
flags |= DESC_I;
} else if (t.equals(LongType.v())) {
flags |= DESC_J;
} else if (t.equals(FloatType.v())) {
flags |= DESC_F;
} else if (t.equals(DoubleType.v())) {
flags |= DESC_D;
}
flags <<= 12;
}
if (Modifier.isPublic(f.getModifiers())) {
flags |= FI_PUBLIC;
} else if (Modifier.isPrivate(f.getModifiers())) {
flags |= FI_PRIVATE;
} else if (Modifier.isProtected(f.getModifiers())) {
flags |= FI_PROTECTED;
}
if (Modifier.isStatic(f.getModifiers())) {
flags |= FI_STATIC;
}
if (Modifier.isFinal(f.getModifiers())) {
flags |= FI_FINAL;
}
if (Modifier.isVolatile(f.getModifiers())) {
flags |= FI_VOLATILE;
}
if (Modifier.isTransient(f.getModifiers())) {
flags |= FI_TRANSIENT;
}
if ((f.getModifiers() & 0x1000) > 0) {
flags |= FI_SYNTHETIC;
}
if (Modifier.isEnum(f.getModifiers())) {
flags |= FI_ENUM;
}
if (attributesEncoder.fieldHasAttributes(f)) {
flags |= FI_ATTRIBUTES;
}
body.add(new IntegerConstant((short) flags));
body.add(getString(f.getName()));
if (!(t instanceof PrimType)) {
body.add(getString(getDescriptor(f)));
}
if (f.isStatic()) {
int index = classFields.indexOf(f);
body.add(offsetof(classType, 1, index, 1));
} else {
int index = instanceFields.indexOf(f);
body.add(offsetof(instanceType, 1, 1 + index, 1));
}
if (attributesEncoder.fieldHasAttributes(f)) {
body.add(new ConstantBitcast(attributesEncoder.getFieldAttributes(f).ref(), I8_PTR));
}
}
for (SootMethod m : sootClass.getMethods()) {
soot.Type t = m.getReturnType();
flags = 0;
if (Modifier.isPublic(m.getModifiers())) {
flags |= MI_PUBLIC;
} else if (Modifier.isPrivate(m.getModifiers())) {
flags |= MI_PRIVATE;
} else if (Modifier.isProtected(m.getModifiers())) {
flags |= MI_PROTECTED;
}
if (Modifier.isStatic(m.getModifiers())) {
flags |= MI_STATIC;
}
if (Modifier.isFinal(m.getModifiers())) {
flags |= MI_FINAL;
}
if (Modifier.isSynchronized(m.getModifiers())) {
flags |= MI_SYNCHRONIZED;
}
if ((m.getModifiers() & 0x0040) > 0) {
flags |= MI_BRIDGE;
}
if ((m.getModifiers() & 0x0080) > 0) {
flags |= MI_VARARGS;
}
if (Modifier.isNative(m.getModifiers())) {
if (!isStruct(sootClass) && !isStructMember(m)) {
flags |= MI_NATIVE;
}
}
if (Modifier.isAbstract(m.getModifiers())) {
flags |= MI_ABSTRACT;
}
if (Modifier.isStrictFP(m.getModifiers())) {
flags |= MI_STRICT;
}
if ((m.getModifiers() & 0x1000) > 0) {
flags |= MI_SYNTHETIC;
}
if (attributesEncoder.methodHasAttributes(m)) {
flags |= MI_ATTRIBUTES;
}
if (isBridge(m)) {
flags |= MI_BRO_BRIDGE;
}
if (isCallback(m)) {
flags |= MI_BRO_CALLBACK;
}
if ((t instanceof PrimType || t == VoidType.v()) && m.getParameterCount() == 0) {
flags |= MI_COMPACT_DESC;
}
body.add(new IntegerConstant((short) flags));
body.add(getString(m.getName()));
if ((flags & MI_COMPACT_DESC) > 0) {
int desc = 0;
if (t.equals(BooleanType.v())) {
desc = DESC_Z;
} else if (t.equals(ByteType.v())) {
desc = DESC_B;
} else if (t.equals(ShortType.v())) {
desc = DESC_S;
} else if (t.equals(CharType.v())) {
desc = DESC_C;
} else if (t.equals(IntType.v())) {
desc = DESC_I;
} else if (t.equals(LongType.v())) {
desc = DESC_J;
} else if (t.equals(FloatType.v())) {
desc = DESC_F;
} else if (t.equals(DoubleType.v())) {
desc = DESC_D;
} else if (t.equals(VoidType.v())) {
desc = DESC_V;
}
body.add(new IntegerConstant((byte) desc));
} else {
body.add(getString(getDescriptor(m)));
}
if (attributesEncoder.methodHasAttributes(m)) {
body.add(new ConstantBitcast(attributesEncoder.getMethodAttributes(m).ref(), I8_PTR));
}
if (!m.isAbstract()) {
body.add(new ConstantBitcast(new FunctionRef(mangleMethod(m), getFunctionType(m)), I8_PTR));
body.add(
new IntegerConstant(
DUMMY_METHOD_SIZE)); // Size of function. This value will be modified later by
// patching the .s file.
if (m.isSynchronized()) {
body.add(
new ConstantBitcast(
new FunctionRef(mangleMethod(m) + "_synchronized", getFunctionType(m)), I8_PTR));
}
}
if (isBridge(m)) {
body.add(new GlobalRef(BridgeMethodCompiler.getTargetFnPtrName(m), I8_PTR));
}
if (isCallback(m)) {
body.add(
new ConstantBitcast(
new FunctionRef(mangleMethod(m) + "_callback", getCallbackFunctionType(m)),
I8_PTR));
}
}
// Return the struct {header, body}. To be compatible with the C code in classinfo.c
// it is important that the header is padded the same as in C so that the body starts
// after sizeof(ClassInfoHeader) bytes.
return new StructureConstantBuilder().add(header.build()).add(body.build()).build();
}
public void printTo(SootClass cl, PrintWriter out) {
// IterableSet packagesUsed = new IterableSet();
IterableSet importList = new IterableSet();
{
String curPackage = cl.getJavaPackageName();
if (!curPackage.equals("")) {
out.println("package " + curPackage + ";");
out.println();
}
if (cl.hasSuperclass()) {
SootClass superClass = cl.getSuperclass();
importList.add(superClass.toString());
// packagesUsed.add(superClass.getJavaPackageName());
}
Iterator<SootClass> interfaceIt = cl.getInterfaces().iterator();
while (interfaceIt.hasNext()) {
String interfacePackage = ((SootClass) interfaceIt.next()).toString();
if (!importList.contains(interfacePackage)) importList.add(interfacePackage);
// if (!packagesUsed.contains(interfacePackage))
// packagesUsed.add(interfacePackage);
}
Iterator<SootMethod> methodIt = cl.methodIterator();
while (methodIt.hasNext()) {
SootMethod dm = (SootMethod) methodIt.next();
if (dm.hasActiveBody()) {
// packagesUsed = packagesUsed.union(((DavaBody) dm.getActiveBody()).get_PackagesUsed());
importList = importList.union(((DavaBody) dm.getActiveBody()).getImportList());
}
Iterator<SootClass> eit = dm.getExceptions().iterator();
while (eit.hasNext()) {
String thrownPackage = eit.next().toString();
if (!importList.contains(thrownPackage)) importList.add(thrownPackage);
// if (!packagesUsed.contains(thrownPackage))
// packagesUsed.add(thrownPackage);
}
Iterator<Type> pit = dm.getParameterTypes().iterator();
while (pit.hasNext()) {
Type t = (Type) pit.next();
if (t instanceof RefType) {
String paramPackage = ((RefType) t).getSootClass().toString();
if (!importList.contains(paramPackage)) importList.add(paramPackage);
// if (packagesUsed.contains(paramPackage) == false)
// packagesUsed.add(paramPackage);
}
}
Type t = dm.getReturnType();
if (t instanceof RefType) {
String returnPackage = ((RefType) t).getSootClass().toString();
if (!importList.contains(returnPackage)) importList.add(returnPackage);
// if (packagesUsed.contains(returnPackage) == false)
// packagesUsed.add(returnPackage);
}
}
Iterator<SootField> fieldIt = cl.getFields().iterator();
while (fieldIt.hasNext()) {
SootField f = (SootField) fieldIt.next();
if (f.isPhantom()) continue;
Type t = f.getType();
if (t instanceof RefType) {
String fieldPackage = ((RefType) t).getSootClass().toString();
if (!importList.contains(fieldPackage)) importList.add(fieldPackage);
}
}
Iterator<String> pit = importList.iterator();
List<String> toImport = new ArrayList<String>();
while (pit.hasNext()) {
/*
* dont import any file which has currentPackage.className
* dont import any file which starts with java.lang
*/
String temp = (String) pit.next();
// System.out.println("temp is "+temp);
if (temp.indexOf("java.lang") > -1) {
// problem is that we need to import sub packages java.lang.ref
// for instance if the type is java.lang.ref.WeakReference
String tempClassName = RemoveFullyQualifiedName.getClassName(temp);
if (temp.equals("java.lang." + tempClassName)) {
// System.out.println("temp was not printed as it belongs to java.lang");
continue;
}
}
if (curPackage.length() > 0 && temp.indexOf(curPackage) > -1) {
// System.out.println("here "+temp);
continue;
}
if (cl.toString().equals(temp)) continue;
// System.out.println("printing"+);
toImport.add(temp);
}
/*
* Check that we are not importing two classes with the same last name
* If yes then remove explicit import and import the whole package
* else output explicit import statement
*/
Iterator it = toImport.iterator();
while (it.hasNext()) {
String temp = (String) it.next();
if (RemoveFullyQualifiedName.containsMultiple(toImport.iterator(), temp, null)) {
// there are atleast two imports with this className
// import package add *
if (temp.lastIndexOf('.') > -1) {
temp = temp.substring(0, temp.lastIndexOf('.'));
out.println("import " + temp + ".*;");
} else throw new DecompilationException("Cant find the DOT . for fullyqualified name");
} else {
if (temp.lastIndexOf('.') == -1) {
// dot not found this is a class belonging to this package so dont add
} else out.println("import " + temp + ";");
}
}
boolean addNewLine = false;
addNewLine = true;
// out.println("import " + temp + ";");
if (addNewLine) out.println();
/*if (!packagesUsed.isEmpty())
out.println();
packagesUsed.add("java.lang");
packagesUsed.add(curPackage);
*/
Dava.v().set_CurrentPackageContext(importList);
// Dava.v().set_CurrentPackageContext(packagesUsed);
Dava.v().set_CurrentPackage(curPackage);
}
// Print class name + modifiers
{
String classPrefix = "";
classPrefix = classPrefix + " " + Modifier.toString(cl.getModifiers());
classPrefix = classPrefix.trim();
if (!cl.isInterface()) {
classPrefix = classPrefix + " class";
classPrefix = classPrefix.trim();
}
out.print(classPrefix + " " + cl.getShortJavaStyleName());
}
// Print extension
if (cl.hasSuperclass() && !(cl.getSuperclass().getName().equals("java.lang.Object"))) {
String superClassName = cl.getSuperclass().getName();
// Nomair Naeem 8th Feb 2006
// also check if the super class name is not a fully qualified
// name. in which case if the package is imported no need for
// the long name
superClassName =
RemoveFullyQualifiedName.getReducedName(importList, superClassName, cl.getType());
out.print(" extends " + superClassName + "");
}
// Print interfaces
{
Iterator<SootClass> interfaceIt = cl.getInterfaces().iterator();
if (interfaceIt.hasNext()) {
if (cl.isInterface()) out.print(" extends ");
else out.print(" implements ");
out.print("" + (interfaceIt.next()).getName() + "");
while (interfaceIt.hasNext()) out.print(", " + (interfaceIt.next()).getName() + "");
}
}
out.println();
out.println("{");
// Print fields
{
Iterator<SootField> fieldIt = cl.getFields().iterator();
if (fieldIt.hasNext()) {
while (fieldIt.hasNext()) {
SootField f = fieldIt.next();
if (f.isPhantom()) continue;
String declaration = null;
Type fieldType = f.getType();
String qualifiers = Modifier.toString(f.getModifiers()) + " ";
qualifiers +=
RemoveFullyQualifiedName.getReducedName(importList, fieldType.toString(), fieldType);
qualifiers = qualifiers.trim();
if (qualifiers.equals("")) declaration = Scene.v().quotedNameOf(f.getName());
else declaration = qualifiers + " " + Scene.v().quotedNameOf(f.getName()) + "";
if (f.isFinal() && f.isStatic()) {
if (fieldType instanceof DoubleType && f.hasTag("DoubleConstantValueTag")) {
double val =
((DoubleConstantValueTag) f.getTag("DoubleConstantValueTag")).getDoubleValue();
out.println(" " + declaration + " = " + val + ";");
} else if (fieldType instanceof FloatType && f.hasTag("FloatConstantValueTag")) {
float val =
((FloatConstantValueTag) f.getTag("FloatConstantValueTag")).getFloatValue();
out.println(" " + declaration + " = " + val + "f;");
} else if (fieldType instanceof LongType && f.hasTag("LongConstantValueTag")) {
long val = ((LongConstantValueTag) f.getTag("LongConstantValueTag")).getLongValue();
out.println(" " + declaration + " = " + val + "l;");
} else if (fieldType instanceof CharType && f.hasTag("IntegerConstantValueTag")) {
int val =
((IntegerConstantValueTag) f.getTag("IntegerConstantValueTag")).getIntValue();
out.println(" " + declaration + " = '" + ((char) val) + "';");
} else if (fieldType instanceof BooleanType && f.hasTag("IntegerConstantValueTag")) {
int val =
((IntegerConstantValueTag) f.getTag("IntegerConstantValueTag")).getIntValue();
if (val == 0) out.println(" " + declaration + " = false;");
else out.println(" " + declaration + " = true;");
} else if ((fieldType instanceof IntType
|| fieldType instanceof ByteType
|| fieldType instanceof ShortType)
&& f.hasTag("IntegerConstantValueTag")) {
int val =
((IntegerConstantValueTag) f.getTag("IntegerConstantValueTag")).getIntValue();
out.println(" " + declaration + " = " + val + ";");
} else if (f.hasTag("StringConstantValueTag")) {
String val =
((StringConstantValueTag) f.getTag("StringConstantValueTag")).getStringValue();
out.println(" " + declaration + " = \"" + val + "\";");
} else {
// System.out.println("Couldnt find type of
// field"+f.getDeclaration());
out.println(" " + declaration + ";");
}
} // field is static final
else {
out.println(" " + declaration + ";");
}
}
}
}
// Print methods
{
Iterator<SootMethod> methodIt = cl.methodIterator();
if (methodIt.hasNext()) {
if (cl.getMethodCount() != 0) out.println();
while (methodIt.hasNext()) {
SootMethod method = (SootMethod) methodIt.next();
if (method.isPhantom()) continue;
if (!Modifier.isAbstract(method.getModifiers())
&& !Modifier.isNative(method.getModifiers())) {
if (!method.hasActiveBody())
throw new RuntimeException("method " + method.getName() + " has no active body!");
else printTo(method.getActiveBody(), out);
if (methodIt.hasNext()) out.println();
} else {
// if method is abstract then print the declaration
out.print(" ");
out.print(method.getDavaDeclaration());
out.println(";");
if (methodIt.hasNext()) out.println();
}
}
}
}
/*
* January 23rd, 2006
* In trying to handle the suepr class problem we need to introduce an inner class
* Instead of creating a data structure for it we are right now just going to print it in the form
* of a string
*
* It would be interesting to later have an internal inner class structure so that we could
* decompile inner classes into inner classes
*/
if (G.v().SootClassNeedsDavaSuperHandlerClass.contains(cl)) {
out.println("\n private static class DavaSuperHandler{");
out.println(" java.util.Vector myVector = new java.util.Vector();");
out.println("\n public Object get(int pos){");
out.println(" return myVector.elementAt(pos);");
out.println(" }");
out.println("\n public void store(Object obj){");
out.println(" myVector.add(obj);");
out.println(" }");
out.println(" }");
}
out.println("}");
}