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();
}
private void compile(Clazz clazz, OutputStream out) throws IOException {
sootClass = clazz.getSootClass();
mb = new ModuleBuilder();
trampolines = new HashSet<Trampoline>();
catches = new HashSet<String>();
classFields = getClassFields(sootClass);
instanceFields = getInstanceFields(sootClass);
classType = getClassType(sootClass);
instanceType = getInstanceType(sootClass);
attributesEncoder.encode(mb, sootClass);
// Add a <clinit> method if the class has ConstantValueTags but no <clinit>.
// This has to be done before createInfoStruct() is called otherwise the
// ClassInfoHeader->initializer value will become NULL and constant static fields
// will never be initialized.
if (!sootClass.declaresMethodByName("<clinit>") && hasConstantValueTags(classFields)) {
SootMethod clinit =
new SootMethod("<clinit>", Collections.EMPTY_LIST, VoidType.v(), Modifier.STATIC);
JimpleBody body = Jimple.v().newBody(clinit);
clinit.setActiveBody(body);
body.getUnits().add(new JReturnVoidStmt());
this.sootClass.addMethod(clinit);
}
if (isStruct(sootClass)) {
if (!Modifier.isFinal(sootClass.getModifiers())) {
throw new IllegalArgumentException("Struct class must be final");
}
SootMethod _sizeOf =
new SootMethod("_sizeOf", Collections.EMPTY_LIST, IntType.v(), Modifier.PROTECTED);
sootClass.addMethod(_sizeOf);
SootMethod sizeOf =
new SootMethod(
"sizeOf", Collections.EMPTY_LIST, IntType.v(), Modifier.PUBLIC | Modifier.STATIC);
sootClass.addMethod(sizeOf);
}
mb.addInclude(
getClass()
.getClassLoader()
.getResource(
String.format("header-%s-%s.ll", config.getOs().getFamily(), config.getArch())));
mb.addInclude(getClass().getClassLoader().getResource("header.ll"));
mb.addFunction(createInstanceof());
mb.addFunction(createCheckcast());
mb.addFunction(createLdcClass());
mb.addFunction(createLdcClassWrapper());
Function allocator = createAllocator();
mb.addFunction(allocator);
mb.addFunction(createClassInitWrapperFunction(allocator.ref()));
for (SootField f : sootClass.getFields()) {
Function getter = createFieldGetter(f);
Function setter = createFieldSetter(f);
mb.addFunction(getter);
mb.addFunction(setter);
if (f.isStatic() && !f.isPrivate()) {
mb.addFunction(createClassInitWrapperFunction(getter.ref()));
if (!f.isFinal()) {
mb.addFunction(createClassInitWrapperFunction(setter.ref()));
}
}
}
for (SootMethod method : sootClass.getMethods()) {
String name = method.getName();
if (isBridge(method)) {
bridgeMethod(method);
} else if (isStruct(sootClass)
&& ("_sizeOf".equals(name) || "sizeOf".equals(name) || isStructMember(method))) {
structMember(method);
} else if (method.isNative()) {
nativeMethod(method);
} else if (!method.isAbstract()) {
method(method);
}
if (!name.equals("<clinit>")
&& !name.equals("<init>")
&& !method.isPrivate()
&& !method.isStatic()
&& !Modifier.isFinal(method.getModifiers())
&& !Modifier.isFinal(sootClass.getModifiers())) {
createLookupFunction(method);
}
if (method.isStatic()) {
String fnName = mangleMethod(method);
if (method.isSynchronized()) {
fnName += "_synchronized";
}
FunctionRef fn = new FunctionRef(fnName, getFunctionType(method));
mb.addFunction(createClassInitWrapperFunction(fn));
}
}
Set<String> trampolineDependencies = new HashSet<String>();
for (Trampoline trampoline : trampolines) {
trampolineResolver.compile(mb, trampoline);
trampolineDependencies.addAll(trampolineResolver.getDependencies());
}
Global classInfoStruct = null;
StructureConstant classInfoErrorStruct = createClassInfoErrorStruct();
if (classInfoErrorStruct != null) {
// The class cannot be loaded at runtime. Replace the ClassInfo struct
// with a ClassInfoError struct with details of why.
classInfoStruct = new Global(mangleClass(sootClass) + "_info_struct", classInfoErrorStruct);
} else {
classInfoStruct =
new Global(mangleClass(sootClass) + "_info_struct", createClassInfoStruct());
}
mb.addGlobal(classInfoStruct);
Function infoFn = FunctionBuilder.infoStruct(sootClass);
infoFn.add(new Ret(new ConstantBitcast(classInfoStruct.ref(), I8_PTR_PTR)));
mb.addFunction(infoFn);
out.write(mb.build().toString().getBytes("UTF-8"));
clazz.clearDependencies();
clazz.addDependency(
"java/lang/Object"); // Make sure no class or interface has zero dependencies
if (sootClass.hasSuperclass() && !sootClass.isInterface()) {
clazz.addDependency(getInternalName(sootClass.getSuperclass()));
}
for (SootClass iface : sootClass.getInterfaces()) {
clazz.addDependency(getInternalName(iface));
}
for (SootField f : sootClass.getFields()) {
addDependencyIfNeeded(clazz, f.getType());
}
for (SootMethod m : sootClass.getMethods()) {
addDependencyIfNeeded(clazz, m.getReturnType());
@SuppressWarnings("unchecked")
List<soot.Type> paramTypes = (List<soot.Type>) m.getParameterTypes();
for (soot.Type type : paramTypes) {
addDependencyIfNeeded(clazz, type);
}
}
clazz.addDependencies(attributesEncoder.getDependencies());
clazz.addDependencies(trampolineDependencies);
clazz.addDependencies(catches);
for (Trampoline t : trampolines) {
if (!(t instanceof LdcString)) {
String desc = t.getTarget();
if (desc.charAt(0) == 'L' || desc.charAt(0) == '[') {
// Target is a descriptor
addDependencyIfNeeded(clazz, desc);
} else {
clazz.addDependency(t.getTarget());
}
}
if (t instanceof FieldAccessor) {
addDependencyIfNeeded(clazz, ((FieldAccessor) t).getFieldDesc());
} else if (t instanceof Invoke) {
String methodDesc = ((Invoke) t).getMethodDesc();
addDependencyIfNeeded(clazz, getReturnTypeDescriptor(methodDesc));
for (String desc : getParameterDescriptors(methodDesc)) {
addDependencyIfNeeded(clazz, desc);
}
}
}
clazz.saveDependencies();
}