soot.jimple.toolkits.annotation.arraycheck.ArrayIndexLivenessAnalysis Maven / Gradle / Ivy

package soot.jimple.toolkits.annotation.arraycheck;

/*-
 * #%L
 * Soot - a J*va Optimization Framework
 * %%
 * Copyright (C) 2000 Feng Qian
 * %%
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation, either version 2.1 of the
 * License, or (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Lesser Public License for more details.
 * 
 * You should have received a copy of the GNU General Lesser Public
 * License along with this program.  If not, see
 * .
 * #L%
 */

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import soot.ArrayType;
import soot.Body;
import soot.IntType;
import soot.Local;
import soot.SootField;
import soot.Type;
import soot.Unit;
import soot.Value;
import soot.ValueBox;
import soot.jimple.AddExpr;
import soot.jimple.ArrayRef;
import soot.jimple.BinopExpr;
import soot.jimple.ConditionExpr;
import soot.jimple.DefinitionStmt;
import soot.jimple.FieldRef;
import soot.jimple.IfStmt;
import soot.jimple.InstanceFieldRef;
import soot.jimple.IntConstant;
import soot.jimple.LengthExpr;
import soot.jimple.MulExpr;
import soot.jimple.NewArrayExpr;
import soot.jimple.NewMultiArrayExpr;
import soot.jimple.StaticFieldRef;
import soot.jimple.Stmt;
import soot.jimple.SubExpr;
import soot.jimple.internal.JAddExpr;
import soot.jimple.internal.JSubExpr;
import soot.options.Options;
import soot.toolkits.graph.DirectedGraph;
import soot.toolkits.graph.ExceptionalUnitGraph;
import soot.toolkits.scalar.BackwardFlowAnalysis;

class ArrayIndexLivenessAnalysis extends BackwardFlowAnalysis {
  private static final Logger logger = LoggerFactory.getLogger(ArrayIndexLivenessAnalysis.class);
  HashSet fullSet = new HashSet();
  ExceptionalUnitGraph eug;

  /*
   * for each unit, kill set has variables to be killed. gen set was considered with conditionOfGenSet, for example, gen set
   * of unit s are valid only when the condition object. was in the living input set.
   */
  HashMap> genOfUnit;
  HashMap> absGenOfUnit;
  HashMap> killOfUnit;
  HashMap> conditionOfGen;

  // s --> a kill all a[?].
  HashMap killArrayRelated;
  // s --> true
  HashMap killAllArrayRef;

  IntContainer zero = new IntContainer(0);

  private final boolean fieldin;
  HashMap> localToFieldRef, fieldToFieldRef;
  HashSet allFieldRefs;

  private final boolean arrayin;
  HashMap localToArrayRef;
  HashSet allArrayRefs;

  private final boolean csin;
  HashMap> localToExpr;

  private final boolean rectarray;
  HashSet multiarraylocals;

  public ArrayIndexLivenessAnalysis(DirectedGraph dg, boolean takeFieldRef, boolean takeArrayRef, boolean takeCSE,
      boolean takeRectArray) {
    super(dg);

    fieldin = takeFieldRef;
    arrayin = takeArrayRef;
    csin = takeCSE;
    rectarray = takeRectArray;

    if (Options.v().debug()) {
      logger.debug("Enter ArrayIndexLivenessAnalysis");
    }

    eug = (ExceptionalUnitGraph) dg;
    retrieveAllArrayLocals(eug.getBody(), fullSet);

    /* compute gen set, kill set, and condition set */
    genOfUnit = new HashMap>(eug.size() * 2 + 1);
    absGenOfUnit = new HashMap>(eug.size() * 2 + 1);
    killOfUnit = new HashMap>(eug.size() * 2 + 1);
    conditionOfGen = new HashMap>(eug.size() * 2 + 1);

    if (fieldin) {
      localToFieldRef = new HashMap>();
      fieldToFieldRef = new HashMap>();
      allFieldRefs = new HashSet();
    }

    if (arrayin) {
      localToArrayRef = new HashMap();
      allArrayRefs = new HashSet();

      killArrayRelated = new HashMap();
      killAllArrayRef = new HashMap();

      if (rectarray) {
        multiarraylocals = new HashSet();
        retrieveMultiArrayLocals(eug.getBody(), multiarraylocals);
      }
    }

    if (csin) {
      localToExpr = new HashMap>();
    }

    getAllRelatedMaps(eug.getBody());

    getGenAndKillSet(eug.getBody(), absGenOfUnit, genOfUnit, killOfUnit, conditionOfGen);

    doAnalysis();

    if (Options.v().debug()) {
      logger.debug("Leave ArrayIndexLivenessAnalysis");
    }
  }

  public HashMap> getLocalToFieldRef() {
    return localToFieldRef;
  }

  public HashMap> getFieldToFieldRef() {
    return fieldToFieldRef;
  }

  public HashSet getAllFieldRefs() {
    return this.allFieldRefs;
  }

  public HashMap getLocalToArrayRef() {
    return localToArrayRef;
  }

  public HashSet getAllArrayRefs() {
    return allArrayRefs;
  }

  public HashMap> getLocalToExpr() {
    return localToExpr;
  }

  public HashSet getMultiArrayLocals() {
    return multiarraylocals;
  }

  private void getAllRelatedMaps(Body body) {
    Iterator unitIt = body.getUnits().iterator();
    while (unitIt.hasNext()) {
      Stmt stmt = (Stmt) unitIt.next();

      if (csin) {
        if (stmt instanceof DefinitionStmt) {
          Value rhs = ((DefinitionStmt) stmt).getRightOp();

          if (rhs instanceof BinopExpr) {
            Value op1 = ((BinopExpr) rhs).getOp1();
            Value op2 = ((BinopExpr) rhs).getOp2();

            if (rhs instanceof AddExpr) {
              // op1 + op2 --> a + b
              if ((op1 instanceof Local) && (op2 instanceof Local)) {
                HashSet refs = localToExpr.get(op1);
                if (refs == null) {
                  refs = new HashSet();
                  localToExpr.put(op1, refs);
                }
                refs.add(rhs);

                refs = localToExpr.get(op2);
                if (refs == null) {
                  refs = new HashSet();
                  localToExpr.put(op2, refs);
                }
                refs.add(rhs);
              }
            }
            // a * b, a * c, c * a
            else if (rhs instanceof MulExpr) {
              HashSet refs = localToExpr.get(op1);
              if (refs == null) {
                refs = new HashSet();
                localToExpr.put(op1, refs);
              }
              refs.add(rhs);

              refs = localToExpr.get(op2);
              if (refs == null) {
                refs = new HashSet();
                localToExpr.put(op2, refs);
              }
              refs.add(rhs);
            } else if (rhs instanceof SubExpr) {
              if (op2 instanceof Local) {
                HashSet refs = localToExpr.get(op2);
                if (refs == null) {
                  refs = new HashSet();
                  localToExpr.put(op2, refs);
                }
                refs.add(rhs);

                if (op1 instanceof Local) {
                  refs = localToExpr.get(op1);
                  if (refs == null) {
                    refs = new HashSet();
                    localToExpr.put(op1, refs);
                  }
                  refs.add(rhs);
                }
              }
            }
          }
        }
      }

      for (ValueBox vbox : stmt.getUseAndDefBoxes()) {
        Value v = vbox.getValue();

        if (fieldin) {
          if (v instanceof InstanceFieldRef) {
            Value base = ((InstanceFieldRef) v).getBase();
            SootField field = ((InstanceFieldRef) v).getField();

            HashSet baseset = localToFieldRef.get(base);
            if (baseset == null) {
              baseset = new HashSet();
              localToFieldRef.put(base, baseset);
            }

            baseset.add(v);

            HashSet fieldset = fieldToFieldRef.get(field);
            if (fieldset == null) {
              fieldset = new HashSet();
              fieldToFieldRef.put(field, fieldset);
            }

            fieldset.add(v);
          }

          if (v instanceof FieldRef) {
            allFieldRefs.add(v);
          }
        }

        if (arrayin) {
          // a = ... --> kill all a[x] nodes.
          // a[i] = .. --> kill all array references.
          // m(a) --> kill all array references
          // i = ... --> kill all array reference with index as i
          /*
           * if (v instanceof ArrayRef) { Value base = ((ArrayRef)v).getBase(); Value index = ((ArrayRef)v).getIndex();
           *
           * HashSet refset = (HashSet)localToArrayRef.get(base); if (refset == null) { refset = new HashSet();
           * localToArrayRef.put(base, refset); } refset.add(v);
           *
           * if (index instanceof Local) { refset = (HashSet)localToArrayRef.get(index); if (refset == null) { refset = new
           * HashSet(); localToArrayRef.put(index, refset); }
           *
           * refset.add(v); } allArrayRefs.add(v); }
           */
        }
      }
    }
  }

  private void retrieveAllArrayLocals(Body body, Set container) {
    for (Local local : body.getLocals()) {
      Type type = local.getType();

      if (type instanceof IntType || type instanceof ArrayType) {
        container.add(local);
      }
    }
  }

  private void retrieveMultiArrayLocals(Body body, Set container) {
    for (Local local : body.getLocals()) {
      Type type = local.getType();

      if (type instanceof ArrayType) {
        if (((ArrayType) type).numDimensions > 1) {
          this.multiarraylocals.add(local);
        }
      }
    }
  }

  private void getGenAndKillSetForDefnStmt(DefinitionStmt asstmt, HashMap> absgen,
      HashSet