[Soot-list] Constant Propagation

[Alefiya Lightwala]

Thankyou.. It solved the problem...

Regards
Alefiya


On Mon, Sep 23, 2013 at 11:28 PM, Bernhard Berger <berber at tzi.de> wrote:

> Hi Alefiya,
>
> I've not checked your code thoroughly but wanted to give you at least one
> pointer. Your copy function is broken since you do not update the
> destination parameter. You overwrite the parameter value. Hope that this
> helps.
>
> Bernhard
>
> Am 23.09.2013 um 19:37 schrieb Alefiya Lightwala <
> alefiya.lightwala90 at gmail.com>:
>
> > package vasco.soot.examples;
> >
> > import java.util.HashMap;
> > import java.util.Map;
> >
> > import soot.Local;
> > import soot.Unit;
> > import soot.Value;
> > import soot.jimple.AssignStmt;
> > import soot.jimple.CastExpr;
> > import soot.jimple.Constant;
> > import soot.jimple.ReturnStmt;
> > import soot.jimple.internal.JimpleLocal;
> > import soot.toolkits.graph.DirectedGraph;
> > import soot.toolkits.graph.UnitGraph;
> > import soot.toolkits.scalar.ArraySparseSet;
> > import soot.toolkits.scalar.FlowSet;
> > import soot.toolkits.scalar.ForwardFlowAnalysis;
> >
> > public class constantprop extends
> ForwardFlowAnalysis<Unit,Map<Local,Constant>>{
> >     private static final Local RETURN_LOCAL = new JimpleLocal("@return",
> null);
> >     DirectedGraph<Unit> graph;
> >     public constantprop(DirectedGraph<Unit> graph) {
> >         super(graph);
> >         this.graph=graph;
> >         doAnalysis();
> >     }
> >     private void assign(Local lhs, Value rhs, Map<Local, Constant>
> input, Map<Local, Constant> output) {
> >         // First remove casts, if any.
> >         if (rhs instanceof CastExpr) {
> >             rhs = ((CastExpr) rhs).getOp();
> >         }
> >         // Then check if the RHS operand is a constant or local
> >         if (rhs instanceof Constant) {
> >             // If RHS is a constant, it is a direct gen
> >             output.put(lhs, (Constant) rhs);
> >         } else if (rhs instanceof Local) {
> >             // Copy constant-status of RHS to LHS (indirect gen), if
> exists
> >             if(input.containsKey(rhs)) {
> >                 output.put(lhs, input.get(rhs));
> >             }
> >         } else {
> >             // RHS is some compound expression, then LHS is non-constant
> (only kill)
> >             output.put(lhs, null);
> >         }
> >     }
> >
> >     @Override
> >     protected void flowThrough(Map<Local, Constant> inValue, Unit unit,
> >             Map<Local, Constant> outValue) {
> >         System.out.println("invalue="+inValue);
> >          copy(inValue,outValue);
> >         // Only statements assigning locals matter
> >         if (unit instanceof AssignStmt) {
> >             // Get operands
> >             Value lhsOp = ((AssignStmt) unit).getLeftOp();
> >             Value rhsOp = ((AssignStmt) unit).getRightOp();
> >             if (lhsOp instanceof Local) {
> >                 assign((Local) lhsOp, rhsOp, inValue, outValue);
> >             }
> >         } else if (unit instanceof ReturnStmt) {
> >             // Get operand
> >             Value rhsOp = ((ReturnStmt) unit).getOp();
> >             assign(RETURN_LOCAL, rhsOp, inValue, outValue);
> >         }
> >         // Return the data flow value at the OUT of the statement
> >
> >     }
> >
> >     @Override
> >     protected void merge(Map<Local, Constant> op1, Map<Local, Constant>
> op2,
> >             Map<Local, Constant> out) {
> >         //Map<Local, Constant> result;
> >         // First add everything in the first operand
> >         copy(op1,out);
> >         FlowSet l = null;
> >         l.add(op1);
> >
> >         // Then add everything in the second operand, bottoming out the
> common keys with different values
> >         for (Local x : op2.keySet()) {
> >             if (op1.containsKey(x)) {
> >                 // Check the values in both operands
> >                 Constant c1 = op1.get(x);
> >                 Constant c2 = op2.get(x);
> >                 if (c1 != null && c1.equals(c2) == false) {
> >                     // Set to non-constant
> >                     out.put(x, null);
> >                 }
> >             } else {
> >                 // Only in second operand, so add as-is
> >                 out.put(x, op2.get(x));
> >             }
> >         }
> >
> >     }
> >
> >     @Override
> >     protected void copy(Map<Local, Constant> source, Map<Local,
> Constant> dest) {
> >         dest = new HashMap<Local,Constant>(source);
> >     }
> >
> >     @Override
> >     protected Map<Local, Constant> entryInitialFlow() {
> >         return new HashMap<Local,Constant>();
> >     }
> >
> >
> >
> >     @Override
> >     protected Map<Local, Constant> newInitialFlow() {
> >         return new HashMap<Local,Constant>();
> >     }
> >
> >
> > }
> >
> > Here I attached code for constant propagation in soot. The values
> computed at OUT of one node are not propagated to IN of its predecessor
> node. IN for all the nodes is null. What is the problem with code?
> >
> > Regards
> > Alefiya
> > _______________________________________________
> > Soot-list mailing list
> > Soot-list at sable.mcgill.ca
> > http://mailman.cs.mcgill.ca/mailman/listinfo/soot-list
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://mailman.cs.mcgill.ca/pipermail/soot-list/attachments/20130923/66f310a8/attachment-0001.html