• Home
• org.soot-oss
• soot
• 4.4.0
• source code
• JasminClass.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

soot.jimple.JasminClass Maven / Gradle / Ivy

package soot.jimple;

/*-
 * #%L
 * Soot - a J*va Optimization Framework
 * %%
 * Copyright (C) 1997 - 1999 Raja Vallee-Rai
 * %%
 * 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.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

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

import soot.AbstractJasminClass;
import soot.ArrayType;
import soot.Body;
import soot.BooleanType;
import soot.ByteType;
import soot.CharType;
import soot.DoubleType;
import soot.FloatType;
import soot.G;
import soot.IntType;
import soot.IntegerType;
import soot.Local;
import soot.LongType;
import soot.Modifier;
import soot.NullType;
import soot.RefType;
import soot.ShortType;
import soot.SootClass;
import soot.SootFieldRef;
import soot.SootMethod;
import soot.SootMethodRef;
import soot.StmtAddressType;
import soot.Timers;
import soot.Trap;
import soot.Type;
import soot.TypeSwitch;
import soot.Unit;
import soot.UnitBox;
import soot.Value;
import soot.ValueBox;
import soot.VoidType;
import soot.grimp.AbstractGrimpValueSwitch;
import soot.grimp.NewInvokeExpr;
import soot.jimple.internal.StmtBox;
import soot.options.Options;
import soot.tagkit.LineNumberTag;
import soot.toolkits.graph.ExceptionalUnitGraph;
import soot.toolkits.graph.ExceptionalUnitGraphFactory;
import soot.toolkits.scalar.FastColorer;
import soot.toolkits.scalar.LocalDefs;
import soot.toolkits.scalar.LocalUses;
import soot.util.Chain;

/*
 * TODO This is the right JasminClass
 */

/** Methods for producing Jasmin code from Jimple. */
public class JasminClass extends AbstractJasminClass {
  private static final Logger logger = LoggerFactory.getLogger(JasminClass.class);

  void emit(String s, int stackChange) {
    modifyStackHeight(stackChange);
    okayEmit(s);
  }

  void modifyStackHeight(int stackChange) {
    if (currentStackHeight > maxStackHeight) {
      maxStackHeight = currentStackHeight;
    }

    currentStackHeight += stackChange;

    if (currentStackHeight < 0) {
      throw new RuntimeException("Stack height is negative!");
    }

    if (currentStackHeight > maxStackHeight) {
      maxStackHeight = currentStackHeight;
    }
  }

  public JasminClass(SootClass sootClass) {
    super(sootClass);
  }

  @Override
  protected void assignColorsToLocals(Body body) {
    super.assignColorsToLocals(body);

    // Call the graph colorer.
    FastColorer.assignColorsToLocals(body, localToGroup, localToColor, groupToColorCount);

    if (Options.v().time()) {
      Timers.v().packTimer.end();
    }
  }

  @Override
  protected void emitMethodBody(SootMethod method) {
    if (Options.v().time()) {
      Timers.v().buildJasminTimer.end();
    }

    Body activeBody = method.getActiveBody();
    if (!(activeBody instanceof StmtBody)) {
      throw new RuntimeException("method: " + method.getName() + " has an invalid active body!");
    }

    StmtBody body = (StmtBody) activeBody;
    body.validate();

    // if(body == null)

    if (Options.v().time()) {
      Timers.v().buildJasminTimer.start();
    }

    if (Options.v().verbose()) {
      logger.debug("[" + body.getMethod().getName() + "] Performing peephole optimizations...");
    }

    subroutineToReturnAddressSlot = new HashMap(10, 0.7f);
    Chain units = body.getUnits();

    // Determine the unitToLabel map
    {
      unitToLabel = new HashMap(units.size() * 2 + 1, 0.7f);
      labelCount = 0;

      for (UnitBox ubox : body.getUnitBoxes(true)) {
        // Assign a label for each statement reference
        StmtBox box = (StmtBox) ubox;
        if (!unitToLabel.containsKey(box.getUnit())) {
          unitToLabel.put(box.getUnit(), "label" + labelCount++);
        }
      }
    }

    // Emit the exceptions
    for (Trap trap : body.getTraps()) {
      if (trap.getBeginUnit() != trap.getEndUnit()) {
        emit(".catch " + slashify(trap.getException().getName()) + " from " + unitToLabel.get(trap.getBeginUnit()) + " to "
            + unitToLabel.get(trap.getEndUnit()) + " using " + unitToLabel.get(trap.getHandlerUnit()));
      }
    }

    int stackLimitIndex = -1;

    // Determine where the locals go
    {
      int localCount = 0;
      int[] paramSlots = new int[method.getParameterCount()];
      int thisSlot = 0;
      Set assignedLocals = new HashSet();
      Map groupColorPairToSlot
          = new HashMap(body.getLocalCount() * 2 + 1, 0.7f);

      localToSlot = new HashMap(body.getLocalCount() * 2 + 1, 0.7f);

      assignColorsToLocals(body);

      // Determine slots for 'this' and parameters
      {
        if (!method.isStatic()) {
          thisSlot = 0;
          localCount++;
        }

        List paramTypes = method.getParameterTypes();
        for (int i = 0; i < paramTypes.size(); i++) {
          paramSlots[i] = localCount;
          localCount += sizeOfType((Type) paramTypes.get(i));
        }
      }

      // Handle identity statements
      for (Unit u : units) {
        if (u instanceof IdentityStmt) {
          IdentityStmt is = (IdentityStmt) u;
          Value leftOp = is.getLeftOp();
          if (leftOp instanceof Local) {
            int slot = 0;

            IdentityRef identity = (IdentityRef) is.getRightOp();
            if (identity instanceof ThisRef) {
              if (method.isStatic()) {
                throw new RuntimeException("Attempting to use 'this' in static method");
              }
              slot = thisSlot;
            } else if (identity instanceof ParameterRef) {
              slot = paramSlots[((ParameterRef) identity).getIndex()];
            } else {
              // Exception ref. Skip over this
              continue;
            }

            Local l = (Local) leftOp;
            // Make this (group, color) point to the given slot,
            // so that all locals of the same color can be pointed here too
            groupColorPairToSlot.put(new GroupIntPair(localToGroup.get(l), localToColor.get(l)), slot);

            localToSlot.put(l, slot);
            assignedLocals.add(l);
          }
        }
      }

      // Assign the rest of the locals
      {
        for (Local local : body.getLocals()) {
          if (!assignedLocals.contains(local)) {
            int slot;
            GroupIntPair pair = new GroupIntPair(localToGroup.get(local), localToColor.get(local));
            if (groupColorPairToSlot.containsKey(pair)) {
              // This local should share the same slot as the previous local with
              // the same (group, color);
              slot = groupColorPairToSlot.get(pair);
            } else {
              slot = localCount;
              localCount += sizeOfType(local.getType());
              groupColorPairToSlot.put(pair, slot);
            }

            localToSlot.put(local, slot);
            assignedLocals.add(local);
          }
        }
        int modifiers = method.getModifiers();
        if (!Modifier.isNative(modifiers) && !Modifier.isAbstract(modifiers)) {
          emit("    .limit stack ?");
          stackLimitIndex = code.size() - 1;
          emit("    .limit locals " + localCount);
        }
      }
    }

    // let's create a u-d web for the ++ peephole optimization.
    ExceptionalUnitGraph stmtGraph = null;
    LocalDefs ld = null;
    LocalUses lu = null;

    // final boolean enablePeephole = !PhaseOptions.getBoolean(options, "no-peephole");
    final boolean enablePeephole = false;
    if (enablePeephole) {
      stmtGraph = ExceptionalUnitGraphFactory.createExceptionalUnitGraph(body);
      ld = G.v().soot_toolkits_scalar_LocalDefsFactory().newLocalDefs(stmtGraph);
      lu = LocalUses.Factory.newLocalUses(body, ld);
    }

    // Emit code in one pass
    {
      isEmittingMethodCode = true;
      maxStackHeight = 0;
      isNextGotoAJsr = false;

      LOOP: for (Iterator codeIt = units.iterator(); codeIt.hasNext();) {
        Stmt s = (Stmt) codeIt.next();

        if (unitToLabel.containsKey(s)) {
          emit(unitToLabel.get(s) + ":");
        }

        if (subroutineToReturnAddressSlot.containsKey(s)) {
          AssignStmt assignStmt = (AssignStmt) s;

          modifyStackHeight(1); // simulate the pushing of address onto the stack by the jsr

          int slot = localToSlot.get(assignStmt.getLeftOp());
          if (slot >= 0 && slot <= 3) {
            emit("astore_" + slot, -1);
          } else {
            emit("astore " + slot, -1);
          }

          // emit("astore " + ( ( Integer ) subroutineToReturnAddressSlot.get( s ) ).intValue() );
        }

        PEEP: if (enablePeephole) {
          // Test for postincrement operators ++ and --
          // We can optimize them further.
          // sanityCheck: see that we have another statement after s.
          if (!(s instanceof AssignStmt) || !codeIt.hasNext()) {
            break PEEP;
          }

          AssignStmt nextStmt;
          Stmt nextNextStmt;
          {
            Stmt ns = (Stmt) stmtGraph.getSuccsOf(s).get(0);
            if (!(ns instanceof AssignStmt)) {
              break PEEP;
            }
            List l = stmtGraph.getSuccsOf(ns);
            if (l.size() != 1) {
              break PEEP;
            }
            nextStmt = (AssignStmt) ns;
            nextNextStmt = (Stmt) l.get(0);
          }

          AssignStmt stmt = (AssignStmt) s;
          final Value lvalue = stmt.getLeftOp();
          final Value rvalue = stmt.getRightOp();

          // we're looking for this pattern:
          // a:  = ;  =  +/- 1; use();
          // b:  = ;  =  +/- 1; use();
          // case a is emitted when rvalue is a local;
          // case b when rvalue is, eg. a field ref.
          //
          // we use structural equality
          // for rvalue & nextStmt.getLeftOp().
          if (!(lvalue instanceof Local) || !nextStmt.getLeftOp().equivTo(rvalue)
              || !(nextStmt.getRightOp() instanceof AddExpr)) {
            break PEEP;
          }

          // make sure that nextNextStmt uses the local exactly once
          {
            boolean foundExactlyOnce = false;
            for (ValueBox box : nextNextStmt.getUseBoxes()) {
              if (box.getValue() == lvalue) {
                if (!foundExactlyOnce) {
                  foundExactlyOnce = true;
                } else {
                  foundExactlyOnce = false;
                  break;
                }
              }
            }
            if (!foundExactlyOnce) {
              break PEEP;
            }
          }

          // Specifically exclude the case where rvalue is on the lhs
          // of nextNextStmt (what a mess!)
          // this takes care of the extremely pathological case where
          // the thing being incremented is also on the lhs of nns (!)
          for (ValueBox box : nextNextStmt.getDefBoxes()) {
            if (box.getValue().equivTo(rvalue)) {
              break PEEP;
            }
          }

          AddExpr addexp = (AddExpr) nextStmt.getRightOp();
          {
            Value op1 = addexp.getOp1();
            if (!op1.equivTo(lvalue) && !op1.equivTo(rvalue)) {
              break PEEP;
            }
            Value op2 = addexp.getOp2();
            if (!(op2 instanceof IntConstant) || ((IntConstant) (op2)).value != 1) {
              break PEEP;
            }
          }

          /* check that we have two uses and that these */
          /* uses live precisely in nextStmt and nextNextStmt */
          /* LocalDefs tells us this: if there was no use, */
          /* there would be no corresponding def. */
          if (addexp.getOp1().equivTo(lvalue)) {
            if (lu.getUsesOf(s).size() != 2 || ld.getDefsOfAt((Local) lvalue, nextStmt).size() != 1
                || ld.getDefsOfAt((Local) lvalue, nextNextStmt).size() != 1) {
              break PEEP;
            }
            plusPlusState = 0;
          } else {
            if (lu.getUsesOf(s).size() != 1 || ld.getDefsOfAt((Local) lvalue, nextNextStmt).size() != 1) {
              break PEEP;
            }
            plusPlusState = 10;
          }

          /* emit dup slot */

          // logger.debug("found ++ instance:");
          // logger.debug(""+s); logger.debug(""+nextStmt);
          // logger.debug(""+nextNextStmt);

          /* this should be redundant, but we do it */
          /* just in case. */
          if (!IntType.v().equals(lvalue.getType())) {
            break PEEP;
          }

          /* our strategy is as follows: eat the */
          /* two incrementing statements, push the lvalue to */
          /* be incremented & its holding local on a */
          /* plusPlusStack and deal with it in */
          /* emitLocal. */

          currentStackHeight = 0;

          /* emit statements as before */
          plusPlusValue = rvalue;
          plusPlusHolder = (Local) lvalue;
          plusPlusIncrementer = nextStmt;

          /* emit new statement with quickness */
          emitStmt(nextNextStmt);

          /* hm. we didn't use local. emit incrementage */
          if (plusPlusHolder != null) {
            emitStmt(s);
            emitStmt(nextStmt);
          }

          if (currentStackHeight != 0) {
            throw new RuntimeException("Stack has height " + currentStackHeight + " after execution of stmt: " + s);
          }
          codeIt.next();
          codeIt.next();
          continue LOOP;
        } // end of peephole opts.

        // emit this statement
        {
          currentStackHeight = 0;
          emitStmt(s);

          if (currentStackHeight != 0) {
            throw new RuntimeException("Stack has height " + currentStackHeight + " after execution of stmt: " + s);
          }
        }
      }

      isEmittingMethodCode = false;

      int modifiers = method.getModifiers();
      if (!Modifier.isNative(modifiers) && !Modifier.isAbstract(modifiers)) {
        code.set(stackLimitIndex, "    .limit stack " + maxStackHeight);
      }
    }
  }

  void emitAssignStmt(AssignStmt stmt) {
    final Value lvalue = stmt.getLeftOp();
    final Value rvalue = stmt.getRightOp();

    // Handle simple subcase where you can use the efficient iinc bytecode
    if (lvalue instanceof Local && (rvalue instanceof AddExpr || rvalue instanceof SubExpr)) {
      Local l = (Local) lvalue;
      BinopExpr expr = (BinopExpr) rvalue;
      Value op1 = expr.getOp1();
      Value op2 = expr.getOp2();

      // more peephole stuff.
      if (lvalue == plusPlusHolder) {
        emitValue(lvalue);
        plusPlusHolder = null;
        plusPlusState = 0;
      }
      // end of peephole

      if (IntType.v().equals(l.getType())) {
        boolean isValidCase = false;
        int x = 0;

        if (op1 == l && op2 instanceof IntConstant) {
          x = ((IntConstant) op2).value;
          isValidCase = true;
        } else if (expr instanceof AddExpr && op2 == l && op1 instanceof IntConstant) {
          // Note expr can't be a SubExpr because that would be x = 3 - x

          x = ((IntConstant) op1).value;
          isValidCase = true;
        }

        if (isValidCase && x >= Short.MIN_VALUE && x <= Short.MAX_VALUE) {
          emit("iinc " + localToSlot.get(l) + " " + ((expr instanceof AddExpr) ? x : -x), 0);
          return;
        }
      }
    }

    lvalue.apply(new AbstractJimpleValueSwitch