com.googlecode.d2j.converter.J2IRConverter Maven / Gradle / Ivy
The newest version!
package com.googlecode.d2j.converter;
import com.googlecode.dex2jar.ir.IrMethod;
import com.googlecode.dex2jar.ir.Trap;
import com.googlecode.dex2jar.ir.expr.Exprs;
import com.googlecode.dex2jar.ir.expr.Local;
import com.googlecode.dex2jar.ir.stmt.*;
import org.objectweb.asm.Handle;
import org.objectweb.asm.Label;
import org.objectweb.asm.Opcodes;
import org.objectweb.asm.Type;
import org.objectweb.asm.tree.*;
import org.objectweb.asm.tree.analysis.AnalyzerException;
import org.objectweb.asm.tree.analysis.Frame;
import org.objectweb.asm.tree.analysis.Interpreter;
import org.objectweb.asm.tree.analysis.Value;
import java.util.*;
import static org.objectweb.asm.Opcodes.*;
public class J2IRConverter {
Map map = new HashMap<>();
InsnList insnList;
int[] parentCount;
JvmFrame[] frames;
MethodNode methodNode;
IrMethod target;
List emitStmts[];
List preEmit = new ArrayList<>();
List currentEmit;
private J2IRConverter() {
}
public static IrMethod convert(String owner, MethodNode methodNode) throws AnalyzerException {
return new J2IRConverter().convert0(owner, methodNode);
}
LabelStmt getLabel(LabelNode labelNode) {
Label label = labelNode.getLabel();
LabelStmt ls = map.get(label);
if (ls == null) {
ls = Stmts.nLabel();
map.put(label, ls);
}
return ls;
}
void emit(Stmt stmt) {
currentEmit.add(stmt);
}
IrMethod populate(String owner, MethodNode source) {
IrMethod target = new IrMethod();
target.name = source.name;
target.owner = "L" + owner + ";";
target.ret = Type.getReturnType(source.desc).getDescriptor();
Type[] args = Type.getArgumentTypes(source.desc);
String sArgs[] = new String[args.length];
target.args = sArgs;
for (int i = 0; i < args.length; i++) {
sArgs[i] = args[i].getDescriptor();
}
target.isStatic = 0 != (source.access & Opcodes.ACC_STATIC);
return target;
}
IrMethod convert0(String owner, MethodNode methodNode) throws AnalyzerException {
this.methodNode = methodNode;
target = populate(owner, methodNode);
if (methodNode.instructions.size() == 0) {
return target;
}
insnList = methodNode.instructions;
BitSet[] exBranch = new BitSet[insnList.size()];
parentCount = new int[insnList.size()];
initParentCount(parentCount);
BitSet handlers = new BitSet(insnList.size());
if (methodNode.tryCatchBlocks != null) {
for (TryCatchBlockNode tcb : methodNode.tryCatchBlocks) {
target.traps.add(new Trap(getLabel(tcb.start), getLabel(tcb.end), new LabelStmt[]{getLabel(tcb.handler)},
new String[]{tcb.type == null ? null : Type.getObjectType(tcb.type).getDescriptor()}));
int handlerIdx = insnList.indexOf(tcb.handler);
handlers.set(handlerIdx);
for (AbstractInsnNode p = tcb.start.getNext(); p != tcb.end; p = p.getNext()) {
BitSet x = exBranch[insnList.indexOf(p)];
if (x == null) {
x = exBranch[insnList.indexOf(p)] = new BitSet(insnList.size());
}
x.set(handlerIdx);
parentCount[handlerIdx]++;
}
}
}
Interpreter interpreter = buildInterpreter();
frames = new JvmFrame[insnList.size()];
emitStmts = new ArrayList[insnList.size()];
BitSet access = new BitSet(insnList.size());
dfs(exBranch, handlers, access, interpreter);
StmtList stmts = target.stmts;
stmts.addAll(preEmit);
for (int i = 0; i < insnList.size(); i++) {
AbstractInsnNode p = insnList.get(i);
if (access.get(i)) {
List es = emitStmts[i];
if (es != null) {
stmts.addAll(es);
}
} else {
if (p.getType() == AbstractInsnNode.LABEL) {
stmts.add(getLabel((LabelNode) p));
}
}
}
emitStmts = null;
Queue queue = new LinkedList<>();
for (int i1 = 0; i1 < frames.length; i1++) {
JvmFrame frame = frames[i1];
if (parentCount[i1] > 1 && frame != null && access.get(i1)) {
for (int j = 0; j < frame.getLocals(); j++) {
JvmValue v = frame.getLocal(j);
addToQueue(queue, v);
}
for (int j = 0; j < frame.getStackSize(); j++) {
addToQueue(queue, frame.getStack(j));
}
}
}
while (!queue.isEmpty()) {
JvmValue v = queue.poll();
getLocal(v);
if (v.parent != null) {
if (v.parent.local == null) {
queue.add(v.parent);
}
}
if (v.otherParent != null) {
for (JvmValue v2 : v.otherParent) {
if (v2.local == null) {
queue.add(v2);
}
}
}
}
Set phiValues = new HashSet<>();
List phiLabels = new ArrayList<>();
for (int i = 0; i < frames.length; i++) {
JvmFrame frame = frames[i];
if (parentCount[i] > 1 && frame != null && access.get(i)) {
AbstractInsnNode p = insnList.get(i);
LabelStmt labelStmt = getLabel((LabelNode) p);
List phis = new ArrayList<>();
for (int j = 0; j < frame.getLocals(); j++) {
JvmValue v = frame.getLocal(j);
addPhi(v, phiValues, phis);
}
for (int j = 0; j < frame.getStackSize(); j++) {
addPhi(frame.getStack(j), phiValues, phis);
}
labelStmt.phis = phis;
phiLabels.add(labelStmt);
}
}
if (phiLabels.size() > 0) {
target.phiLabels = phiLabels;
}
return target;
}
private void addPhi(JvmValue v, Set phiValues, List phis) {
if (v != null) {
if (v.local != null) {
if (v.parent != null) {
phiValues.add(getLocal(v.parent));
}
if (v.otherParent != null) {
for (JvmValue v2 : v.otherParent) {
phiValues.add(getLocal(v2));
}
}
if (phiValues.size() > 0) {
phis.add(Stmts.nAssign(v.local, Exprs.nPhi(phiValues.toArray(new com.googlecode.dex2jar.ir.expr.Value[phiValues.size()]))));
phiValues.clear();
}
}
}
}
private void addToQueue(Queue queue, JvmValue v) {
if (v != null) {
if (v.local != null) {
if (v.parent != null) {
if (v.parent.local == null) {
queue.add(v.parent);
}
}
if (v.otherParent != null) {
for (JvmValue v2 : v.otherParent) {
if (v2.local == null) {
queue.add(v2);
}
}
}
}
}
}
private void dfs(BitSet[] exBranch, BitSet handlers, BitSet access, Interpreter interpreter) throws AnalyzerException {
currentEmit = preEmit;
JvmFrame first = initFirstFrame(methodNode, target);
if (parentCount[0] > 1) {
merge(first, 0);
} else {
frames[0] = first;
}
Stack stack = new Stack<>();
stack.push(insnList.getFirst());
JvmFrame tmp = new JvmFrame(methodNode.maxLocals, methodNode.maxStack);
while (!stack.isEmpty()) {
AbstractInsnNode p = stack.pop();
int index = insnList.indexOf(p);
if (!access.get(index)) {
access.set(index);
} else {
continue;
}
JvmFrame frame = frames[index];
setCurrentEmit(index);
if (p.getType() == AbstractInsnNode.LABEL) {
emit(getLabel((LabelNode) p));
if (handlers.get(index)) {
Local ex = newLocal();
emit(Stmts.nIdentity(ex, Exprs.nExceptionRef("Ljava/lang/Throwable;")));
frame.clearStack();
frame.push(new JvmValue(1, ex));
}
}
BitSet ex = exBranch[index];
if (ex != null) {
for (int i = ex.nextSetBit(0); i >= 0; i = ex.nextSetBit(i + 1)) {
mergeEx(frame, i);
stack.push(insnList.get(i));
}
}
tmp.init(frame);
tmp.execute(p, interpreter);
int op = p.getOpcode();
if (p.getType() == AbstractInsnNode.JUMP_INSN) {
JumpInsnNode jump = (JumpInsnNode) p;
stack.push(jump.label);
merge(tmp, insnList.indexOf(jump.label));
}
if (op == Opcodes.TABLESWITCH || op == Opcodes.LOOKUPSWITCH) {
if (op == Opcodes.TABLESWITCH) {
TableSwitchInsnNode tsin = (TableSwitchInsnNode) p;
for (LabelNode label : tsin.labels) {
stack.push(label);
merge(tmp, insnList.indexOf(label));
}
stack.push(tsin.dflt);
merge(tmp, insnList.indexOf(tsin.dflt));
} else {
LookupSwitchInsnNode lsin = (LookupSwitchInsnNode) p;
for (LabelNode label : lsin.labels) {
stack.push(label);
merge(tmp, insnList.indexOf(label));
}
stack.push(lsin.dflt);
merge(tmp, insnList.indexOf(lsin.dflt));
}
}
if ((op >= Opcodes.GOTO && op <= Opcodes.RETURN) || op == Opcodes.ATHROW) {
// can't continue
} else {
stack.push(p.getNext());
merge(tmp, index + 1);
}
// cleanup frame it is useless
if (parentCount[index] <= 1) {
frames[index] = null;
}
}
}
private void setCurrentEmit(int index) {
currentEmit = emitStmts[index];
if (currentEmit == null) {
currentEmit = emitStmts[index] = new ArrayList<>(1);
}
}
private Interpreter buildInterpreter() {
return new Interpreter(Opcodes.ASM4) {
@Override
public JvmValue newValue(Type type) {
return null;
}
@Override
public JvmValue newOperation(AbstractInsnNode insn) throws AnalyzerException {
switch (insn.getOpcode()) {
case ACONST_NULL:
return b(1, Exprs.nNull());
case ICONST_M1:
case ICONST_0:
case ICONST_1:
case ICONST_2:
case ICONST_3:
case ICONST_4:
case ICONST_5:
return b(1, Exprs.nInt(insn.getOpcode() - ICONST_0));
case LCONST_0:
case LCONST_1:
return b(2, Exprs.nLong(insn.getOpcode() - LCONST_0));
case FCONST_0:
case FCONST_1:
case FCONST_2:
return b(1, Exprs.nFloat(insn.getOpcode() - FCONST_0));
case DCONST_0:
case DCONST_1:
return b(2, Exprs.nDouble(insn.getOpcode() - DCONST_0));
case BIPUSH:
case SIPUSH:
return b(1, Exprs.nInt(((IntInsnNode) insn).operand));
case LDC:
Object cst = ((LdcInsnNode) insn).cst;
if (cst instanceof Integer) {
return b(1, Exprs.nInt((Integer) cst));
} else if (cst instanceof Float) {
return b(1, Exprs.nFloat((Float) cst));
} else if (cst instanceof Long) {
return b(2, Exprs.nLong((Long) cst));
} else if (cst instanceof Double) {
return b(2, Exprs.nDouble((Double) cst));
} else if (cst instanceof String) {
return b(1, Exprs.nString((String) cst));
} else if (cst instanceof Type) {
Type type = (Type) cst;
int sort = type.getSort();
if (sort == Type.OBJECT || sort == Type.ARRAY) {
return b(1, Exprs.nType(type.getDescriptor()));
} else if (sort == Type.METHOD) {
throw new UnsupportedOperationException("Not supported yet.");
} else {
throw new IllegalArgumentException("Illegal LDC constant " + cst);
}
} else if (cst instanceof Handle) {
throw new UnsupportedOperationException("Not supported yet.");
} else {
throw new IllegalArgumentException("Illegal LDC constant " + cst);
}
case JSR:
throw new UnsupportedOperationException("Not supported yet.");
case GETSTATIC:
FieldInsnNode fin = (FieldInsnNode) insn;
return b(Type.getType(fin.desc).getSize(), Exprs.nStaticField("L" + fin.owner + ";", fin.name,
fin.desc));
case NEW:
return b(1, Exprs.nNew("L" + ((TypeInsnNode) insn).desc + ";"));
default:
throw new Error("Internal error.");
}
}
@Override
public JvmValue copyOperation(AbstractInsnNode insn, JvmValue value) throws AnalyzerException {
return b(value.getSize(), getLocal(value));
}
@Override
public JvmValue unaryOperation(AbstractInsnNode insn, JvmValue value0) throws AnalyzerException {
Local local = value0 == null ? null : getLocal(value0);
switch (insn.getOpcode()) {
case INEG:
return b(1, Exprs.nNeg(local, "I"));
case IINC:
return b(1, Exprs.nAdd(local, Exprs.nInt(((IincInsnNode) insn).incr), "I"));
case L2I:
return b(1, Exprs.nCast(local, "J", "I"));
case F2I:
return b(1, Exprs.nCast(local, "F", "I"));
case D2I:
return b(1, Exprs.nCast(local, "D", "I"));
case I2B:
return b(1, Exprs.nCast(local, "I", "B"));
case I2C:
return b(1, Exprs.nCast(local, "I", "C"));
case I2S:
return b(1, Exprs.nCast(local, "I", "S"));
case FNEG:
return b(1, Exprs.nNeg(local, "F"));
case I2F:
return b(1, Exprs.nCast(local, "I", "F"));
case L2F:
return b(1, Exprs.nCast(local, "J", "F"));
case D2F:
return b(1, Exprs.nCast(local, "D", "F"));
case LNEG:
return b(2, Exprs.nNeg(local, "J"));
case I2L:
return b(2, Exprs.nCast(local, "I", "J"));
case F2L:
return b(2, Exprs.nCast(local, "F", "J"));
case D2L:
return b(2, Exprs.nCast(local, "D", "J"));
case DNEG:
return b(2, Exprs.nNeg(local, "D"));
case I2D:
return b(2, Exprs.nCast(local, "I", "D"));
case L2D:
return b(2, Exprs.nCast(local, "J", "D"));
case F2D:
return b(2, Exprs.nCast(local, "F", "D"));
case IFEQ:
emit(Stmts.nIf(Exprs.nEq(local, Exprs.nInt(0), "I"),
getLabel(((JumpInsnNode) insn).label)));
return null;
case IFNE:
emit(Stmts.nIf(Exprs.nNe(local, Exprs.nInt(0), "I"),
getLabel(((JumpInsnNode) insn).label)));
return null;
case IFLT:
emit(Stmts.nIf(Exprs.nLt(local, Exprs.nInt(0), "I"),
getLabel(((JumpInsnNode) insn).label)));
return null;
case IFGE:
emit(Stmts.nIf(Exprs.nGe(local, Exprs.nInt(0), "I"),
getLabel(((JumpInsnNode) insn).label)));
return null;
case IFGT:
emit(Stmts.nIf(Exprs.nGt(local, Exprs.nInt(0), "I"),
getLabel(((JumpInsnNode) insn).label)));
return null;
case IFLE:
emit(Stmts.nIf(Exprs.nLe(local, Exprs.nInt(0), "I"),
getLabel(((JumpInsnNode) insn).label)));
return null;
case TABLESWITCH: {
TableSwitchInsnNode ts = (TableSwitchInsnNode) insn;
LabelStmt targets[] = new LabelStmt[ts.labels.size()];
for (int i = 0; i < ts.labels.size(); i++) {
targets[i] = getLabel((LabelNode) ts.labels.get(i));
}
emit(Stmts.nTableSwitch(local, ts.min, targets, getLabel(ts.dflt)));
return null;
}
case LOOKUPSWITCH: {
LookupSwitchInsnNode ls = (LookupSwitchInsnNode) insn;
LabelStmt targets[] = new LabelStmt[ls.labels.size()];
int[] lookupValues = new int[ls.labels.size()];
for (int i = 0; i < ls.labels.size(); i++) {
targets[i] = getLabel((LabelNode) ls.labels.get(i));
lookupValues[i] = (Integer) ls.keys.get(i);
}
emit(Stmts.nLookupSwitch(local, lookupValues, targets, getLabel(ls.dflt)));
return null;
}
case IRETURN:
case LRETURN:
case FRETURN:
case DRETURN:
case ARETURN:
// skip, move to returnOperation
return null;
case PUTSTATIC: {
FieldInsnNode fin = (FieldInsnNode) insn;
emit(Stmts.nAssign(Exprs.nStaticField("L" + fin.owner + ";", fin.name, fin.desc), local));
return null;
}
case GETFIELD: {
FieldInsnNode fin = (FieldInsnNode) insn;
Type fieldType = Type.getType(fin.desc);
return b(fieldType.getSize(), Exprs.nField(local, "L" + fin.owner + ";", fin.name, fin.desc));
}
case NEWARRAY:
switch (((IntInsnNode) insn).operand) {
case T_BOOLEAN:
return b(1, Exprs.nNewArray("Z", local));
case T_CHAR:
return b(1, Exprs.nNewArray("C", local));
case T_BYTE:
return b(1, Exprs.nNewArray("B", local));
case T_SHORT:
return b(1, Exprs.nNewArray("S", local));
case T_INT:
return b(1, Exprs.nNewArray("I", local));
case T_FLOAT:
return b(1, Exprs.nNewArray("F", local));
case T_DOUBLE:
return b(1, Exprs.nNewArray("D", local));
case T_LONG:
return b(1, Exprs.nNewArray("D", local));
default:
throw new AnalyzerException(insn, "Invalid array type");
}
case ANEWARRAY:
String desc = "L" + ((TypeInsnNode) insn).desc + ";";
return b(1, Exprs.nNewArray(desc, local));
case ARRAYLENGTH:
return b(1, Exprs.nLength(local));
case ATHROW:
emit(Stmts.nThrow(local));
return null;
case CHECKCAST:
String orgDesc = ((TypeInsnNode) insn).desc;
desc = orgDesc.startsWith("[") ? orgDesc : ("L" + orgDesc + ";");
return b(1, Exprs.nCheckCast(local, desc));
case INSTANCEOF:
return b(1, Exprs.nInstanceOf(local, "L" + ((TypeInsnNode) insn).desc + ";"));
case MONITORENTER:
emit(Stmts.nLock(local));
return null;
case MONITOREXIT:
emit(Stmts.nUnLock(local));
return null;
case IFNULL:
emit(Stmts.nIf(Exprs.nEq(local, Exprs.nNull(), "L"),
getLabel(((JumpInsnNode) insn).label)));
return null;
case IFNONNULL:
emit(Stmts.nIf(Exprs.nNe(local, Exprs.nNull(), "L"),
getLabel(((JumpInsnNode) insn).label)));
return null;
case GOTO: // special case
emit(Stmts.nGoto(getLabel(((JumpInsnNode) insn).label)));
return null;
default:
throw new Error("Internal error.");
}
}
JvmValue b(int size, com.googlecode.dex2jar.ir.expr.Value value) {
Local local = newLocal();
emit(Stmts.nAssign(local, value));
return new JvmValue(size, local);
}
@Override
public JvmValue binaryOperation(AbstractInsnNode insn, JvmValue value10, JvmValue value20)
throws AnalyzerException {
Local local1 = getLocal(value10);
Local local2 = getLocal(value20);
switch (insn.getOpcode()) {
case IALOAD:
return b(1, Exprs.nArray(local1, local2, "I"));
case BALOAD:
return b(1, Exprs.nArray(local1, local2, "B"));
case CALOAD:
return b(1, Exprs.nArray(local1, local2, "C"));
case SALOAD:
return b(1, Exprs.nArray(local1, local2, "S"));
case FALOAD:
return b(1, Exprs.nArray(local1, local2, "F"));
case AALOAD:
return b(1, Exprs.nArray(local1, local2, "L"));
case DALOAD:
return b(1, Exprs.nArray(local1, local2, "D"));
case LALOAD:
return b(1, Exprs.nArray(local1, local2, "J"));
case IADD:
return b(1, Exprs.nAdd(local1, local2, "I"));
case ISUB:
return b(1, Exprs.nSub(local1, local2, "I"));
case IMUL:
return b(1, Exprs.nMul(local1, local2, "I"));
case IDIV:
return b(1, Exprs.nDiv(local1, local2, "I"));
case IREM:
return b(1, Exprs.nRem(local1, local2, "I"));
case ISHL:
return b(1, Exprs.nShl(local1, local2, "I"));
case ISHR:
return b(1, Exprs.nShr(local1, local2, "I"));
case IUSHR:
return b(1, Exprs.nUshr(local1, local2, "I"));
case IAND:
return b(1, Exprs.nAnd(local1, local2, "I"));
case IOR:
return b(1, Exprs.nOr(local1, local2, "I"));
case IXOR:
return b(1, Exprs.nXor(local1, local2, "I"));
case FADD:
return b(1, Exprs.nAdd(local1, local2, "F"));
case FSUB:
return b(1, Exprs.nSub(local1, local2, "F"));
case FMUL:
return b(1, Exprs.nMul(local1, local2, "F"));
case FDIV:
return b(1, Exprs.nDiv(local1, local2, "F"));
case FREM:
return b(1, Exprs.nRem(local1, local2, "F"));
case LADD:
return b(2, Exprs.nAdd(local1, local2, "J"));
case LSUB:
return b(2, Exprs.nSub(local1, local2, "J"));
case LMUL:
return b(2, Exprs.nMul(local1, local2, "J"));
case LDIV:
return b(2, Exprs.nDiv(local1, local2, "J"));
case LREM:
return b(2, Exprs.nRem(local1, local2, "J"));
case LSHL:
return b(2, Exprs.nShl(local1, local2, "J"));
case LSHR:
return b(2, Exprs.nShr(local1, local2, "J"));
case LUSHR:
return b(2, Exprs.nUshr(local1, local2, "J"));
case LAND:
return b(2, Exprs.nAnd(local1, local2, "J"));
case LOR:
return b(2, Exprs.nOr(local1, local2, "J"));
case LXOR:
return b(2, Exprs.nXor(local1, local2, "J"));
case DADD:
return b(2, Exprs.nAdd(local1, local2, "D"));
case DSUB:
return b(2, Exprs.nSub(local1, local2, "D"));
case DMUL:
return b(2, Exprs.nMul(local1, local2, "D"));
case DDIV:
return b(2, Exprs.nDiv(local1, local2, "D"));
case DREM:
return b(2, Exprs.nRem(local1, local2, "D"));
case LCMP:
return b(2, Exprs.nLCmp(local1, local2));
case FCMPL:
return b(1, Exprs.nFCmpl(local1, local2));
case FCMPG:
return b(1, Exprs.nFCmpg(local1, local2));
case DCMPL:
return b(2, Exprs.nDCmpl(local1, local2));
case DCMPG:
return b(2, Exprs.nDCmpg(local1, local2));
case IF_ICMPEQ:
emit(Stmts.nIf(Exprs.nEq(local1, local2, "I"),
getLabel(((JumpInsnNode) insn).label)));
return null;
case IF_ICMPNE:
emit(Stmts.nIf(Exprs.nNe(local1, local2, "I"),
getLabel(((JumpInsnNode) insn).label)));
return null;
case IF_ICMPLT:
emit(Stmts.nIf(Exprs.nLt(local1, local2, "I"),
getLabel(((JumpInsnNode) insn).label)));
return null;
case IF_ICMPGE:
emit(Stmts.nIf(Exprs.nGe(local1, local2, "I"),
getLabel(((JumpInsnNode) insn).label)));
return null;
case IF_ICMPGT:
emit(Stmts.nIf(Exprs.nGt(local1, local2, "I"),
getLabel(((JumpInsnNode) insn).label)));
return null;
case IF_ICMPLE:
emit(Stmts.nIf(Exprs.nLe(local1, local2, "I"),
getLabel(((JumpInsnNode) insn).label)));
return null;
case IF_ACMPEQ:
emit(Stmts.nIf(Exprs.nEq(local1, local2, "L"),
getLabel(((JumpInsnNode) insn).label)));
return null;
case IF_ACMPNE:
emit(Stmts.nIf(Exprs.nNe(local1, local2, "L"),
getLabel(((JumpInsnNode) insn).label)));
return null;
case PUTFIELD:
FieldInsnNode fin = (FieldInsnNode) insn;
emit(Stmts.nAssign(Exprs.nField(local1, "L" + fin.owner + ";", fin.name, fin.desc), local2));
return null;
default:
throw new Error("Internal error.");
}
}
@Override
public JvmValue ternaryOperation(AbstractInsnNode insn, JvmValue value1, JvmValue value2, JvmValue value3)
throws AnalyzerException {
Local local1 = getLocal(value1);
Local local2 = getLocal(value2);
Local local3 = getLocal(value3);
switch (insn.getOpcode()) {
case IASTORE:
emit(Stmts.nAssign(Exprs.nArray(local1, local2, "I"),
local3));
break;
case LASTORE:
emit(Stmts.nAssign(Exprs.nArray(local1, local2, "J"),
local3));
break;
case FASTORE:
emit(Stmts.nAssign(Exprs.nArray(local1, local2, "F"),
local3));
break;
case DASTORE:
emit(Stmts.nAssign(Exprs.nArray(local1, local2, "D"),
local3));
break;
case AASTORE:
emit(Stmts.nAssign(Exprs.nArray(local1, local2, "L"),
local3));
break;
case BASTORE:
emit(Stmts.nAssign(Exprs.nArray(local1, local2, "B"),
local3));
break;
case CASTORE:
emit(Stmts.nAssign(Exprs.nArray(local1, local2, "C"),
local3));
break;
case SASTORE:
emit(Stmts.nAssign(Exprs.nArray(local1, local2, "S"),
local3));
break;
}
return null;
}
public String[] toDescArray(Type[] ts) {
String[] ds = new String[ts.length];
for (int i = 0; i < ts.length; i++) {
ds[i] = ts[i].getDescriptor();
}
return ds;
}
@Override
public JvmValue naryOperation(AbstractInsnNode insn, List xvalues) throws AnalyzerException {
com.googlecode.dex2jar.ir.expr.Value values[] = new com.googlecode.dex2jar.ir.expr.Value[xvalues.size()];
for (int i = 0; i < xvalues.size(); i++) {
values[i] = getLocal(xvalues.get(i));
}
if (insn.getOpcode() == MULTIANEWARRAY) {
throw new UnsupportedOperationException("Not supported yet.");
} else {
MethodInsnNode mi = (MethodInsnNode) insn;
com.googlecode.dex2jar.ir.expr.Value v = null;
String ret = Type.getReturnType(mi.desc).getDescriptor();
String owner = "L" + mi.owner + ";";
String ps[] = toDescArray(Type.getArgumentTypes(mi.desc));
switch (insn.getOpcode()) {
case INVOKEVIRTUAL:
v = Exprs.nInvokeVirtual(values, owner, mi.name, ps, ret);
break;
case INVOKESPECIAL:
v = Exprs.nInvokeSpecial(values, owner, mi.name, ps, ret);
break;
case INVOKESTATIC:
v = Exprs.nInvokeStatic(values, owner, mi.name, ps, ret);
break;
case INVOKEINTERFACE:
v = Exprs.nInvokeInterface(values, owner, mi.name, ps, ret);
break;
case INVOKEDYNAMIC:
throw new UnsupportedOperationException("Not supported yet.");
}
if ("V".equals(ret)) {
emit(Stmts.nVoidInvoke(v));
return null;
} else {
return b(Type.getReturnType(mi.desc).getSize(), v);
}
}
}
@Override
public JvmValue merge(JvmValue v, JvmValue w) {
throw new UnsupportedOperationException("Not supported yet.");
}
@Override
public void returnOperation(AbstractInsnNode insn, JvmValue value, JvmValue expected) throws AnalyzerException {
switch (insn.getOpcode()) {
case IRETURN:
case LRETURN:
case FRETURN:
case DRETURN:
case ARETURN:
emit(Stmts.nReturn(getLocal(value)));
break;
case RETURN:
emit(Stmts.nReturnVoid());
break;
}
}
};
}
Local getLocal(JvmValue value) {
Local local = value.local;
if (local == null) {
local = value.local = newLocal();
}
return local;
}
private void initParentCount(int[] parentCount) {
parentCount[0] = 1;
for (AbstractInsnNode p = insnList.getFirst(); p != null; p = p.getNext()) {
if (p.getType() == AbstractInsnNode.JUMP_INSN) {
JumpInsnNode jump = (JumpInsnNode) p;
parentCount[insnList.indexOf(jump.label)]++;
}
int op = p.getOpcode();
if (op == Opcodes.TABLESWITCH || op == Opcodes.LOOKUPSWITCH) {
if (op == Opcodes.TABLESWITCH) {
TableSwitchInsnNode tsin = (TableSwitchInsnNode) p;
for (LabelNode label : tsin.labels) {
parentCount[insnList.indexOf(label)]++;
}
parentCount[insnList.indexOf(tsin.dflt)]++;
} else {
LookupSwitchInsnNode lsin = (LookupSwitchInsnNode) p;
for (LabelNode label : lsin.labels) {
parentCount[insnList.indexOf(label)]++;
}
parentCount[insnList.indexOf(lsin.dflt)]++;
}
}
if ((op >= Opcodes.GOTO && op <= Opcodes.RETURN) || op == Opcodes.ATHROW) {
// can't continue
} else {
AbstractInsnNode next = p.getNext();
if(next!=null) {
parentCount[insnList.indexOf(p.getNext())]++;
}
}
}
}
private void mergeEx(JvmFrame src, int dst) {
JvmFrame distFrame = frames[dst];
if (distFrame == null) {
distFrame = frames[dst] = new JvmFrame(methodNode.maxLocals, methodNode.maxStack);
}
for (int i = 0; i < src.getLocals(); i++) {
JvmValue p = src.getLocal(i);
JvmValue q = distFrame.getLocal(i);
if (p != null) {
if (q == null) {
q = new JvmValue(p.getSize());
distFrame.setLocal(i, q);
}
relate(p, q);
}
}
}
private void merge(JvmFrame src, int dst) {
JvmFrame distFrame = frames[dst];
if (distFrame == null) {
distFrame = frames[dst] = new JvmFrame(methodNode.maxLocals, methodNode.maxStack);
}
if (parentCount[dst] > 1) {
for (int i = 0; i < src.getLocals(); i++) {
JvmValue p = src.getLocal(i);
JvmValue q = distFrame.getLocal(i);
if (p != null) {
if (q == null) {
q = new JvmValue(p.getSize());
distFrame.setLocal(i, q);
}
relate(p, q);
}
}
if (src.getStackSize() > 0) {
if (distFrame.getStackSize() == 0) {
for (int i = 0; i < src.getStackSize(); i++) {
distFrame.push(new JvmValue(src.getStack(i).getSize()));
}
} else if (distFrame.getStackSize() != src.getStackSize()) {
throw new RuntimeException("stack not balanced");
}
for (int i = 0; i < src.getStackSize(); i++) {
JvmValue p = src.getStack(i);
JvmValue q = distFrame.getStack(i);
relate(p, q);
}
}
} else {
distFrame.init(src);
}
}
private void relate(JvmValue parent, JvmValue child) {
if (child.parent == null) {
child.parent = parent;
} else if (child.parent == parent) {
//
} else {
if (child.otherParent == null) {
child.otherParent = new HashSet<>(5);
}
child.otherParent.add(parent);
}
}
private JvmFrame initFirstFrame(MethodNode methodNode, IrMethod target) {
JvmFrame first = new JvmFrame(methodNode.maxLocals, methodNode.maxStack);
int x = 0;
if (!target.isStatic) {// not static
Local thiz = newLocal();
emit(Stmts.nIdentity(thiz, Exprs.nThisRef(target.owner)));
first.setLocal(x++, new JvmValue(1, thiz));
}
for (int i = 0; i < target.args.length; i++) {
Local p = newLocal();
emit(Stmts.nIdentity(p, Exprs.nParameterRef(target.args[i], i)));
int sizeOfType = sizeOfType(target.args[i]);
first.setLocal(x, new JvmValue(sizeOfType, p));
x += sizeOfType;
}
return first;
}
private int sizeOfType(String arg) {
switch (arg.charAt(0)) {
case 'J':
case 'D':
return 2;
default:
return 1;
}
}
private Local newLocal() {
Local thiz = Exprs.nLocal(target.locals.size());
target.locals.add(thiz);
return thiz;
}
static class JvmFrame extends Frame {
public JvmFrame(int nLocals, int nStack) {
super(nLocals, nStack);
}
@Override
public void execute(AbstractInsnNode insn, Interpreter interpreter) throws AnalyzerException {
if (insn.getType() == AbstractInsnNode.FRAME || insn.getType() == AbstractInsnNode.LINE || insn.getType() == AbstractInsnNode.LABEL) {
return;
}
if (insn.getOpcode() == Opcodes.RETURN) {
interpreter.returnOperation(insn, null, null);
} else if (insn.getOpcode() == Opcodes.GOTO) {
interpreter.unaryOperation(insn, null);
} else if (insn.getOpcode() == RET) {
throw new RuntimeException("not support yet!");
} else {
super.execute(insn, interpreter);
}
}
}
public static class JvmValue implements Value {
private final int size;
public JvmValue parent;
public Set otherParent;
Local local;
public JvmValue(int size, Local local) {
this.size = size;
this.local = local;
}
public JvmValue(int size) {
this.size = size;
}
@Override
public int getSize() {
return size;
}
}
}
© 2015 - 2024 Weber Informatics LLC | Privacy Policy