Examples with VarExpr org.mapleir.ir.code.expr.VarExpr used on opensource projects

Example 21 with VarExpr

use of org.mapleir.ir.code.expr.VarExpr in project maple-ir by LLVM-but-worse.

the class SSAGenPass method reduceClass.

private void reduceClass(Set<CopyPhiStmt> cc, CopyPhiStmt preferred) {
    Set<CopyPhiStmt> useless = new HashSet<>(cc);
    useless.remove(preferred);
    VersionedLocal phiLocal = (VersionedLocal) preferred.getVariable().getLocal();
    /* all the *dead* phi class locals */
    Set<VersionedLocal> deadLocals = new HashSet<>();
    for (CopyPhiStmt def : useless) {
        VersionedLocal local = (VersionedLocal) def.getVariable().getLocal();
        deadLocals.add(local);
        for (Expr e : def.enumerateOnlyChildren()) {
            if (e.getOpcode() == Opcode.LOCAL_LOAD) {
                VarExpr v = (VarExpr) e;
                VersionedLocal vl = (VersionedLocal) v.getLocal();
                pool.uses.get(vl).remove(v);
            }
        }
        // System.out.println(" killing " + def);
        def.delete();
    }
    for (VersionedLocal vl : deadLocals) {
        Set<VarExpr> deadVExprs = pool.uses.get(vl);
        for (VarExpr v : deadVExprs) {
            /* v.getLocal() == vl, i.e. dead phi local.
				 * Replace each dead var with the real one. */
            v.setLocal(phiLocal);
            pool.uses.get(phiLocal).add(v);
        }
        /* all dead. */
        /*pool.uses.get(vl)*/
        deadVExprs.clear();
        pool.defs.remove(vl);
    }
}

Example 22 with VarExpr

use of org.mapleir.ir.code.expr.VarExpr in project maple-ir by LLVM-but-worse.

the class SSAGenPass method splitRanges.

private void splitRanges() {
    // produce cleaner cfg
    List<BasicBlock> order = new ArrayList<>(builder.graph.vertices());
    NullPermeableHashMap<BasicBlock, Set<Local>> splits = new NullPermeableHashMap<>(SetCreator.getInstance());
    for (ExceptionRange<BasicBlock> er : builder.graph.getRanges()) {
        BasicBlock h = er.getHandler();
        handlers.add(h);
        Set<Local> ls = new HashSet<>(liveness.in(h));
        for (BasicBlock b : er.get()) {
            splits.getNonNull(b).addAll(ls);
        }
    }
    for (Entry<BasicBlock, Set<Local>> e : splits.entrySet()) {
        BasicBlock b = e.getKey();
        Set<Local> ls = e.getValue();
        ArrayList<Stmt> stmtsCopy = new ArrayList<>(b);
        int i = 0;
        boolean checkSplit = false;
        for (int i1 = 0; i1 < stmtsCopy.size(); i1++) {
            Stmt stmt = stmtsCopy.get(i1);
            if (b.size() == i)
                throw new IllegalStateException("s");
            if (checkSplit && stmt.getOpcode() == Opcode.LOCAL_STORE) {
                CopyVarStmt copy = (CopyVarStmt) stmt;
                VarExpr v = copy.getVariable();
                if (ls.contains(v.getLocal())) {
                    BasicBlock n = splitBlock(b, i);
                    order.add(order.indexOf(b), n);
                    i = 0;
                    checkSplit = false;
                }
            } else {
                // do not split if we have only seen simple or synthetic copies (catch copy is synthetic)
                if (stmt instanceof CopyVarStmt) {
                    CopyVarStmt copy = (CopyVarStmt) stmt;
                    int opc = copy.getExpression().getOpcode();
                    if (!copy.isSynthetic() && opc != Opcode.LOCAL_LOAD && opc != Opcode.CATCH) {
                        checkSplit = true;
                    }
                } else {
                    checkSplit = true;
                }
            }
            i++;
        }
    }
    builder.graph.naturalise(order);
    int po = 0;
    for (BasicBlock b : SimpleDfs.preorder(builder.graph, builder.graph.getEntries().iterator().next())) {
        insertion.put(b, 0);
        process.put(b, 0);
        preorder.put(b, po++);
    }
}

Example 23 with VarExpr

use of org.mapleir.ir.code.expr.VarExpr in project maple-ir by LLVM-but-worse.

the class SSAGenPass method translateStmt.

private void translateStmt(VarExpr var, boolean resolve, boolean isPhi) {
    /* Here we only remap local variable loads
		 * on the right hand side of a statement or
		 * expression. This means that if we are able
		 * to simply replace a local load which has
		 * a constant or deferred local value.
		 * 
		 * However, if the value of the local is
		 * a complex expression we need to check that
		 * we can propagate it before we do.
		 * 
		 * Since we will only replace a single
		 * local load in the original expression,
		 * only 1 variable is killed. However, there
		 * may be local load expressions in the
		 * propagated expression. To account for this,
		 * these local loads must be counted as new
		 * uses (except for when an expression is
		 * moved instead of copied to a use site).*/
    Local l = var.getLocal();
    VersionedLocal ssaL;
    if (resolve) {
        ssaL = latest(l.getIndex(), l.isStack());
    } else {
        ssaL = (VersionedLocal) l;
    }
    pool.uses.get(ssaL).add(var);
    VersionedLocal newL = ssaL;
    boolean exists = true;
    if (OPTIMISE) {
        if (latest.containsKey(ssaL)) {
            /* Try to propagate a simple copy local
				 * to its use site. It is possible that
				 * a non simple copy (including phis)
				 * will not have a mapping. In this case
				 * they will not have an updated target.*/
            LatestValue value = latest.get(ssaL);
            boolean unpredictable = value.getType() == LatestValue.PARAM || value.getType() == LatestValue.PHI;
            if (unpredictable && ssaL != value.getSuggestedValue()) {
                VersionedLocal vl = (VersionedLocal) value.getSuggestedValue();
                if (shouldPropagate(ssaL, vl)) {
                    newL = vl;
                }
            } else if (!isPhi && !unpredictable) {
                Expr e = null;
                AbstractCopyStmt def = pool.defs.get(ssaL);
                Expr rval = (Expr) value.getSuggestedValue();
                if (ConstraintUtil.isUncopyable(rval)) {
                    /* A variable might have a value
						 * that is uncopyable such as an
						 * invoke or allocation call.
						 * 
						 * There are two ways this may happen:
						 *   x = call();
						 *  or
						 *   x = call();
						 *   y = x;
						 *   
						 * we defer optimising the first
						 * case till the end.
						 * 
						 * in the second case, we can
						 * propagate the source var (x)
						 * in place of the target (y). */
                    newL = tryDefer(value, ssaL);
                } else {
                    AbstractCopyStmt from = def;
                    if (value.getSource() != null) {
                        from = pool.defs.get(value.getSource());
                    }
                    if (!value.hasConstraints() || (canTransferHandlers(def.getBlock(), var.getBlock()) && value.canPropagate(from, var.getRootParent(), var, false))) {
                        if (shouldCopy(rval)) {
                            e = rval;
                        } else {
                            newL = tryDefer(value, ssaL);
                        }
                    } else if (value.getRealValue() instanceof VersionedLocal) {
                        VersionedLocal realVal = (VersionedLocal) value.getRealValue();
                        if (shouldPropagate(ssaL, realVal)) {
                            newL = realVal;
                        } else {
                            shadowed.getNonNull(ssaL).add(realVal);
                            shadowed.getNonNull(realVal).add(ssaL);
                        }
                    }
                }
                if (e != null) {
                    // System.out.println("=====");
                    // System.out.println("   ssaL: " + ssaL);
                    // System.out.println("   bpar: " + var.getParent());
                    CodeUnit parent = var.getParent();
                    int idx = parent.indexOf(var);
                    parent.overwrite(e = e.copy(), idx);
                    // System.out.println("    def: " + def);
                    // System.out.println("    idx: " + idx);
                    // System.out.println("    val: " + value);
                    // System.out.println("   apar: " + parent);
                    // System.out.println("      e: " + e);
                    /* Remove the use of the var before
						 * we translate the children of the 
						 * newly propagated expression.*/
                    pool.uses.get(ssaL).remove(var);
                    // System.out.println("   uses: " + pool.uses.get(ssaL));
                    /* Account for the new pool.uses.*/
                    collectUses(e);
                    /* Finally see if we can reduce
						 * this statement further.*/
                    translate(e, false, isPhi);
                    exists = false;
                }
            } else {
                newL = ssaL;
            }
        } else {
            throw new IllegalStateException("No (self) ancestors: " + l + " -> " + ssaL);
        }
    }
    if (exists) {
        if (OPTIMISE) {
            // System.out.println("replace: " + ssaL + " with " + newL);
            if (ssaL != newL) {
                // System.out.println(ssaL + "  -->  " + newL);
                pool.uses.get(ssaL).remove(var);
                pool.uses.get(newL).add(var);
            }
        }
        /* If the expression still exists, update
			 * or set both variable and type information.*/
        var.setLocal(newL);
        Type type = types.get(ssaL);
        if (type == null) {
            throw new IllegalStateException(var + ", " + ssaL + ", t=null");
        } else {
            var.setType(type);
        }
    }
}

Example 24 with VarExpr

use of org.mapleir.ir.code.expr.VarExpr in project maple-ir by LLVM-but-worse.

the class SSAGenPass method generate.

private VersionedLocal generate(AbstractCopyStmt copy) {
    VarExpr v = copy.getVariable();
    Local oldLocal = v.getLocal();
    int index = oldLocal.getIndex();
    boolean isStack = oldLocal.isStack();
    LocalsPool handler = builder.graph.getLocals();
    Local l = handler.get(index, isStack);
    int subscript = counters.get(l);
    stacks.get(l).push(subscript);
    counters.put(l, subscript + 1);
    VersionedLocal ssaL = handler.get(index, subscript, isStack);
    if (OPTIMISE) {
        makeValue(copy, ssaL);
    }
    v.setLocal(ssaL);
    pool.defs.put(ssaL, copy);
    types.put(ssaL, copy.getExpression().getType());
    pool.uses.put(ssaL, new HashSet<>());
    return ssaL;
}

Example 25 with VarExpr

use of org.mapleir.ir.code.expr.VarExpr in project maple-ir by LLVM-but-worse.

the class SSAGenPass method fixPhiArgs.

private void fixPhiArgs(BasicBlock b, BasicBlock succ) {
    for (Stmt stmt : succ) {
        if (stmt.getOpcode() == Opcode.PHI_STORE) {
            CopyPhiStmt copy = (CopyPhiStmt) stmt;
            PhiExpr phi = copy.getExpression();
            Expr e = phi.getArgument(b);
            if (e.getOpcode() == Opcode.LOCAL_LOAD) {
                VarExpr v = (VarExpr) e;
                translate(v, true, true);
                VersionedLocal ssaL = (VersionedLocal) v.getLocal();
                Type t = types.get(ssaL);
                copy.getVariable().setType(t);
                phi.setType(t);
            } else {
                throw new IllegalArgumentException(phi + ", " + e);
            }
        } else {
            /* No need to search the rest of the block
				 * after we have visited the phis as they
				 * precede all other statements.
				 */
            break;
        }
    }
}