private static final Logger logger = LoggerFactory.getLogger(AsmMethodSource.class);

private static final Operand DWORD_DUMMY = new Operand(null, null);

private static final String METAFACTORY_SIGNATURE = "<java.lang.invoke.LambdaMetafactory: java.lang.invoke.CallSite "

+ "metafactory(java.lang.invoke.MethodHandles$Lookup,java.lang.String,java.lang.invoke.MethodType,"

+ "java.lang.invoke.MethodType,java.lang.invoke.MethodHandle,java.lang.invoke.MethodType)>";

private static final String ALT_METAFACTORY_SIGNATURE = "<java.lang.invoke.LambdaMetafactory: java.lang.invoke.CallSite "

+ "altMetafactory(java.lang.invoke.MethodHandles$Lookup,"

+ "java.lang.String,java.lang.invoke.MethodType,java.lang.Object[])>";

/* -const fields- */

private final String module;

private final int maxLocals;

private final InsnList instructions;

private final List<LocalVariableNode> localVars;

private final List<TryCatchBlockNode> tryCatchBlocks;

private final Set<LabelNode> inlineExceptionLabels = new LinkedHashSet<LabelNode>();

private final Map<LabelNode, Unit> inlineExceptionHandlers = new LinkedHashMap<LabelNode, Unit>();

private final CastAndReturnInliner castAndReturnInliner = new CastAndReturnInliner();

/* -state fields- */

protected int nextLocal;

protected Map<Integer, Local> locals;

private Multimap<LabelNode, UnitBox> labels;

private Map<AbstractInsnNode, Unit> units;

private ArrayList<Operand> stack;

private Map<AbstractInsnNode, StackFrame> frames;

private Multimap<LabelNode, UnitBox> trapHandlers;

private JimpleBody body;

private int lastLineNumber = -1;

private Table<AbstractInsnNode, AbstractInsnNode, Edge> edges;

private ArrayDeque<Edge> conversionWorklist;

public AsmMethodSource(int maxLocals, InsnList insns, List<LocalVariableNode> localVars,

List<TryCatchBlockNode> tryCatchBlocks, String module) {

this.maxLocals = maxLocals;

this.instructions = insns;

this.localVars = localVars;

this.tryCatchBlocks = tryCatchBlocks;

this.module = module;

}

private StackFrame getFrame(AbstractInsnNode insn) {

StackFrame frame = frames.get(insn);

if (frame == null) {

frame = new StackFrame(this);

frames.put(insn, frame);

}

return frame;

}

private SootClass getClassFromScene(String className) {

SootClass result;

if (ModuleUtil.module_mode()) {

result = ModuleScene.v().getSootClassUnsafe(className, Optional.fromNullable(this.module));

} else {

result = Scene.v().getSootClassUnsafe(className);

}

if (result == null) {

String msg = String.format("%s was not found on classpath.", className);

if (Options.v().allow_phantom_refs()) {

RefType ref = RefType.v(className);

// make sure nobody else creates the same class

synchronized (ref) {

logger.warn(msg);

result = Scene.v().makeSootClass(className, Modifier.PUBLIC);

Scene.v().addClass(result);

result.setPhantomClass();

return ref.getSootClass();

}

} else {

throw new RuntimeException(msg);

}

}

return result;

}

private Local getLocal(int idx) {

if (idx >= maxLocals) {

throw new IllegalArgumentException("Invalid local index: " + idx);

}

Integer i = idx;

Local l = locals.get(i);

if (l == null) {

String name = getLocalName(idx);

l = Jimple.v().newLocal(name, UnknownType.v());

locals.put(i, l);

}

return l;

}

protected String getLocalName(int idx) {

String name;

if (localVars != null) {

name = null;

for (LocalVariableNode lvn : localVars) {

// Ignore LocalVariableNode which don't cover any real units

if (lvn.index == idx && lvn.start != lvn.end) {

name = lvn.name;

break;

}

}

/* normally for try-catch blocks */

if (name == null) {

name = "l" + idx;

}

} else {

name = "l" + idx;

}

return name;

}

private void push(Operand opr) {

stack.add(opr);

}

private void pushDual(Operand opr) {

stack.add(DWORD_DUMMY);

stack.add(opr);

}

private Operand peek() {

return stack.get(stack.size() - 1);

}

private void push(Type t, Operand opr) {

if (AsmUtil.isDWord(t)) {

pushDual(opr);

} else {

push(opr);

}

}

private Operand pop() {

if (stack.isEmpty()) {

throw new RuntimeException("Stack underrun");

}

return stack.remove(stack.size() - 1);

}

private Operand popDual() {

Operand o = pop();

Operand o2 = pop();

if (o2 != DWORD_DUMMY && o2 != o) {

throw new AssertionError("Not dummy operand, " + o2.value + " -- " + o.value);

}

return o;

}

private Operand pop(Type t) {

return AsmUtil.isDWord(t) ? popDual() : pop();

}

private Operand popLocal(Operand o) {

Value v = o.value;

Local l = o.stack;

if (l == null && !(v instanceof Local)) {

l = o.stack = newStackLocal();

setUnit(o.insn, Jimple.v().newAssignStmt(l, v));

o.updateBoxes();

}

return o;

}

private Operand popImmediate(Operand o) {

Value v = o.value;

Local l = o.stack;

if (l == null && !(v instanceof Local) && !(v instanceof Constant)) {

l = o.stack = newStackLocal();

setUnit(o.insn, Jimple.v().newAssignStmt(l, v));

o.updateBoxes();

}

return o;

}

private Operand popStackConst(Operand o) {

Value v = o.value;

Local l = o.stack;

if (l == null && !(v instanceof Constant)) {

l = o.stack = newStackLocal();

setUnit(o.insn, Jimple.v().newAssignStmt(l, v));

o.updateBoxes();

}

return o;

}

private Operand popLocal() {

return popLocal(pop());

}

private Operand popLocalDual() {

return popLocal(popDual());

}

@SuppressWarnings("unused")

private Operand popLocal(Type t) {

return AsmUtil.isDWord(t) ? popLocalDual() : popLocal();

}

private Operand popImmediate() {

return popImmediate(pop());

}

private Operand popImmediateDual() {

return popImmediate(popDual());

}

private Operand popImmediate(Type t) {

return AsmUtil.isDWord(t) ? popImmediateDual() : popImmediate();

}

private Operand popStackConst() {

return popStackConst(pop());

}

private Operand popStackConstDual() {

return popStackConst(popDual());

}

@SuppressWarnings("unused")

private Operand popStackConst(Type t) {

return AsmUtil.isDWord(t) ? popStackConstDual() : popStackConst();

}

void setUnit(AbstractInsnNode insn, Unit u) {

if (Options.v().keep_line_number() && lastLineNumber >= 0) {

Tag lineTag = u.getTag(LineNumberTag.NAME);

if (lineTag == null) {

lineTag = new LineNumberTag(lastLineNumber);

u.addTag(lineTag);

} else if (((LineNumberTag) lineTag).getLineNumber() != lastLineNumber) {

throw new RuntimeException("Line tag mismatch");

}

}

Unit o = units.put(insn, u);

if (o != null) {

throw new AssertionError(insn.getOpcode() + " already has a unit, " + o);

}

}

void mergeUnits(AbstractInsnNode insn, Unit u) {

Unit prev = units.put(insn, u);

if (prev != null) {

Unit merged = new UnitContainer(prev, u);

units.put(insn, merged);

}

}

protected Local newStackLocal() {

Integer idx = nextLocal++;

Local l = Jimple.v().newLocal("$stack" + idx, UnknownType.v());

locals.put(idx, l);

return l;

}

@SuppressWarnings("unchecked")

<A extends Unit> A getUnit(AbstractInsnNode insn) {

return (A) units.get(insn);

}

private void assignReadOps(Local l) {

if (stack.isEmpty()) {

return;

}

for (Operand opr : stack) {

if (opr == DWORD_DUMMY || opr.stack != null || (l == null && opr.value instanceof Local)) {

continue;

}

if (l != null && !opr.value.equivTo(l)) {

List<ValueBox> uses = opr.value.getUseBoxes();

boolean noref = true;

for (ValueBox use : uses) {

Value val = use.getValue();

if (val.equivTo(l)) {

noref = false;

break;

}

}

if (noref) {

continue;

}

}

int op = opr.insn.getOpcode();

if (l == null && op != GETFIELD && op != GETSTATIC && (op < IALOAD && op > SALOAD)) {

continue;

}

Local stack = newStackLocal();

opr.stack = stack;

AssignStmt as = Jimple.v().newAssignStmt(stack, opr.value);

opr.updateBoxes();

setUnit(opr.insn, as);

}

}

private void convertGetFieldInsn(FieldInsnNode insn) {

StackFrame frame = getFrame(insn);

Operand[] out = frame.out();

Operand opr;

Type type;

if (out == null) {

SootClass declClass = this.getClassFromScene(AsmUtil.toQualifiedName(insn.owner));

type = AsmUtil.toJimpleType(insn.desc, Optional.fromNullable(this.body.getMethod().getDeclaringClass().moduleName));

Value val;

SootFieldRef ref;

if (insn.getOpcode() == GETSTATIC) {

ref = Scene.v().makeFieldRef(declClass, insn.name, type, true);

val = Jimple.v().newStaticFieldRef(ref);

} else {

Operand base = popLocal();

ref = Scene.v().makeFieldRef(declClass, insn.name, type, false);

InstanceFieldRef ifr = Jimple.v().newInstanceFieldRef(base.stackOrValue(), ref);

val = ifr;

base.addBox(ifr.getBaseBox());

frame.in(base);

frame.boxes(ifr.getBaseBox());

}

opr = new Operand(insn, val);

frame.out(opr);

} else {

opr = out[0];

type = opr.<FieldRef>value().getFieldRef().type();

if (insn.getOpcode() == GETFIELD) {

frame.mergeIn(pop());

}

}

push(type, opr);

}

private void convertPutFieldInsn(FieldInsnNode insn) {

boolean instance = insn.getOpcode() == PUTFIELD;

StackFrame frame = getFrame(insn);

Operand[] out = frame.out();

Operand opr, rvalue;

Type type;

if (out == null) {

SootClass declClass = this.getClassFromScene(AsmUtil.toQualifiedName(insn.owner));

type = AsmUtil.toJimpleType(insn.desc, Optional.fromNullable(this.body.getMethod().getDeclaringClass().moduleName));

Value val;

SootFieldRef ref;

rvalue = popImmediate(type);

if (!instance) {

ref = Scene.v().makeFieldRef(declClass, insn.name, type, true);

val = Jimple.v().newStaticFieldRef(ref);

frame.in(rvalue);

} else {

Operand base = popLocal();

ref = Scene.v().makeFieldRef(declClass, insn.name, type, false);

InstanceFieldRef ifr = Jimple.v().newInstanceFieldRef(base.stackOrValue(), ref);

val = ifr;

base.addBox(ifr.getBaseBox());

frame.in(rvalue, base);

}

opr = new Operand(insn, val);

frame.out(opr);

AssignStmt as = Jimple.v().newAssignStmt(val, rvalue.stackOrValue());

rvalue.addBox(as.getRightOpBox());

if (!instance) {

frame.boxes(as.getRightOpBox());

} else {

frame.boxes(as.getRightOpBox(), ((InstanceFieldRef) val).getBaseBox());

}

setUnit(insn, as);

} else {

opr = out[0];

type = opr.<FieldRef>value().getFieldRef().type();

rvalue = pop(type);

if (!instance) {

/* PUTSTATIC only needs one operand on the stack, the rvalue */

frame.mergeIn(rvalue);

} else {

/* PUTFIELD has a rvalue and a base */

frame.mergeIn(rvalue, pop());

}

}

/*

assignReadOps(null);

}

private void convertFieldInsn(FieldInsnNode insn) {

int op = insn.getOpcode();

if (op == GETSTATIC || op == GETFIELD) {

convertGetFieldInsn(insn);

} else {

convertPutFieldInsn(insn);

}

}

private void convertIincInsn(IincInsnNode insn) {

Local local = getLocal(insn.var);

assignReadOps(local);

if (!units.containsKey(insn)) {

AddExpr add = Jimple.v().newAddExpr(local, IntConstant.v(insn.incr));

setUnit(insn, Jimple.v().newAssignStmt(local, add));

}

}

private void convertConstInsn(InsnNode insn) {

int op = insn.getOpcode();

StackFrame frame = getFrame(insn);

Operand[] out = frame.out();

Operand opr;

if (out == null) {

Value v;

if (op == ACONST_NULL) {

v = NullConstant.v();

} else if (op >= ICONST_M1 && op <= ICONST_5) {

v = IntConstant.v(op - ICONST_0);

} else if (op == LCONST_0 || op == LCONST_1) {

v = LongConstant.v(op - LCONST_0);

} else if (op >= FCONST_0 && op <= FCONST_2) {

v = FloatConstant.v(op - FCONST_0);

} else if (op == DCONST_0 || op == DCONST_1) {

v = DoubleConstant.v(op - DCONST_0);

} else {

throw new AssertionError("Unknown constant opcode: " + op);

}

opr = new Operand(insn, v);

frame.out(opr);

} else {

opr = out[0];

}

if (op == LCONST_0 || op == LCONST_1 || op == DCONST_0 || op == DCONST_1) {

pushDual(opr);

} else {

push(opr);

}

}

/*

/*

private void convertArrayLoadInsn(InsnNode insn) {

StackFrame frame = getFrame(insn);

Operand[] out = frame.out();

Operand opr;

if (out == null) {

Operand indx = popImmediate();

Operand base = popImmediate();

// We have a sample of totally broken code with a reference to a null array

// x = null[i]

// We silently fix this issue and return a null value

if (base.value == NullConstant.v()) {

opr = new Operand(insn, NullConstant.v());

frame.in(indx, base);

frame.out(opr);

} else {

ArrayRef ar = Jimple.v().newArrayRef(base.stackOrValue(), indx.stackOrValue());

indx.addBox(ar.getIndexBox());

base.addBox(ar.getBaseBox());

opr = new Operand(insn, ar);

frame.in(indx, base);

frame.boxes(ar.getIndexBox(), ar.getBaseBox());

frame.out(opr);

}

} else {

opr = out[0];

frame.mergeIn(pop(), pop());

}

int op = insn.getOpcode();

if (op == DALOAD || op == LALOAD) {

pushDual(opr);

} else {

push(opr);

}

}

private void convertArrayStoreInsn(InsnNode insn) {

int op = insn.getOpcode();

boolean dword = op == LASTORE || op == DASTORE;

StackFrame frame = getFrame(insn);

if (!units.containsKey(insn)) {

Operand valu = dword ? popImmediateDual() : popImmediate();

Operand indx = popImmediate();

Operand base = popLocal();

ArrayRef ar = Jimple.v().newArrayRef(base.stackOrValue(), indx.stackOrValue());

indx.addBox(ar.getIndexBox());

base.addBox(ar.getBaseBox());

AssignStmt as = Jimple.v().newAssignStmt(ar, valu.stackOrValue());

valu.addBox(as.getRightOpBox());

frame.in(valu, indx, base);

frame.boxes(as.getRightOpBox(), ar.getIndexBox(), ar.getBaseBox());

setUnit(insn, as);

} else {

frame.mergeIn(dword ? popDual() : pop(), pop(), pop());

}

}

private void convertDupInsn(InsnNode insn) {

int op = insn.getOpcode();

// Get the top stack value which we need in either case

Operand dupd = popImmediate();

Operand dupd2 = null;

// Some instructions allow operands that take two registers

boolean dword = op == DUP2 || op == DUP2_X1 || op == DUP2_X2;

if (dword) {

if (peek() == DWORD_DUMMY) {

pop();

dupd2 = dupd;

} else {

dupd2 = popImmediate();

}

}

switch (op) {

case DUP: {

// val -> val, val

push(dupd);

push(dupd);

break;

}

case DUP_X1: {

// val2, val1 -> val1, val2, val1

// value1, value2 must not be of type double or long

Operand o2 = popImmediate();

push(dupd);

push(o2);

push(dupd);

break;

}

case DUP_X2: {

// value3, value2, value1 -> value1, value3, value2, value1

Operand o2 = popImmediate();

Operand o3 = peek() == DWORD_DUMMY ? pop() : popImmediate();

push(dupd);

push(o3);

push(o2);

push(dupd);

break;

}

case DUP2: {

// value2, value1 -> value2, value1, value2, value1

push(dupd2);

push(dupd);

push(dupd2);

push(dupd);

break;

}

case DUP2_X1: {

// value3, value2, value1 -> value2, value1, value3, value2, value1

// Attention: value2 may be

Operand o2 = popImmediate();

push(dupd2);

push(dupd);

push(o2);

push(dupd2);

push(dupd);

break;

}

case DUP2_X2: {

// (value4, value3), (value2, value1) -> (value2, value1), (value4, value3), (value2, value1)

Operand o2 = popImmediate();

Operand o2h = peek() == DWORD_DUMMY ? pop() : popImmediate();

push(dupd2);

push(dupd);

push(o2h);

push(o2);

push(dupd2);

push(dupd);

break;

}

default:

break;

}

}

private void convertBinopInsn(InsnNode insn) {

int op = insn.getOpcode();

boolean dword = op == DADD || op == LADD || op == DSUB || op == LSUB || op == DMUL || op == LMUL || op == DDIV

|| op == LDIV || op == DREM || op == LREM || op == LSHL || op == LSHR || op == LUSHR || op == LAND || op == LOR

|| op == LXOR || op == LCMP || op == DCMPL || op == DCMPG;

StackFrame frame = getFrame(insn);

Operand[] out = frame.out();

Operand opr;

if (out == null) {

Operand op2 = (dword && op != LSHL && op != LSHR && op != LUSHR) ? popImmediateDual() : popImmediate();

Operand op1 = dword ? popImmediateDual() : popImmediate();

Value v1 = op1.stackOrValue();

Value v2 = op2.stackOrValue();

BinopExpr binop;

if (op >= IADD && op <= DADD) {

binop = Jimple.v().newAddExpr(v1, v2);

} else if (op >= ISUB && op <= DSUB) {

binop = Jimple.v().newSubExpr(v1, v2);

} else if (op >= IMUL && op <= DMUL) {

binop = Jimple.v().newMulExpr(v1, v2);

} else if (op >= IDIV && op <= DDIV) {

binop = Jimple.v().newDivExpr(v1, v2);

} else if (op >= IREM && op <= DREM) {

binop = Jimple.v().newRemExpr(v1, v2);

} else if (op >= ISHL && op <= LSHL) {

binop = Jimple.v().newShlExpr(v1, v2);

} else if (op >= ISHR && op <= LSHR) {

binop = Jimple.v().newShrExpr(v1, v2);

} else if (op >= IUSHR && op <= LUSHR) {

binop = Jimple.v().newUshrExpr(v1, v2);

} else if (op >= IAND && op <= LAND) {

binop = Jimple.v().newAndExpr(v1, v2);

} else if (op >= IOR && op <= LOR) {

binop = Jimple.v().newOrExpr(v1, v2);

} else if (op >= IXOR && op <= LXOR) {

binop = Jimple.v().newXorExpr(v1, v2);

} else if (op == LCMP) {

binop = Jimple.v().newCmpExpr(v1, v2);

} else if (op == FCMPL || op == DCMPL) {

binop = Jimple.v().newCmplExpr(v1, v2);

} else if (op == FCMPG || op == DCMPG) {

binop = Jimple.v().newCmpgExpr(v1, v2);

} else {

throw new AssertionError("Unknown binop: " + op);

}

op1.addBox(binop.getOp1Box());

op2.addBox(binop.getOp2Box());

opr = new Operand(insn, binop);

frame.in(op2, op1);

frame.boxes(binop.getOp2Box(), binop.getOp1Box());

frame.out(opr);

} else {

opr = out[0];

if (dword) {

if (op != LSHL && op != LSHR && op != LUSHR) {

frame.mergeIn(popDual(), popDual());

} else {

frame.mergeIn(pop(), popDual());

}

} else {

frame.mergeIn(pop(), pop());

}

}

if (dword && (op < LCMP || op > DCMPG)) {

pushDual(opr);

} else {

push(opr);

}

}

private void convertUnopInsn(InsnNode insn) {

int op = insn.getOpcode();

boolean dword = op == LNEG || op == DNEG;

StackFrame frame = getFrame(insn);

Operand[] out = frame.out();

Operand opr;

if (out == null) {

Operand op1 = dword ? popImmediateDual() : popImmediate();

Value v1 = op1.stackOrValue();

UnopExpr unop;

if (op >= INEG && op <= DNEG) {

unop = Jimple.v().newNegExpr(v1);

} else if (op == ARRAYLENGTH) {

unop = Jimple.v().newLengthExpr(v1);

} else {

throw new AssertionError("Unknown unop: " + op);

}

op1.addBox(unop.getOpBox());

opr = new Operand(insn, unop);

frame.in(op1);

frame.boxes(unop.getOpBox());

frame.out(opr);

} else {

opr = out[0];

frame.mergeIn(dword ? popDual() : pop());

}

if (dword) {

pushDual(opr);

} else {

push(opr);

}

}

private void convertPrimCastInsn(InsnNode insn) {

int op = insn.getOpcode();

boolean tod = op == I2L || op == I2D || op == F2L || op == F2D || op == D2L || op == L2D;