com.android.dx.ssa.SsaMethod Java Examples

/**
 * Ensures that all the phi result registers for all the phis in the
 * same basic block interfere with each other, and also that a phi's source
 * registers interfere with the result registers from other phis. This is needed since
 * the dead code remover has allowed through "dead-end phis" whose
 * results are not used except as local assignments. Without this step,
 * a the result of a dead-end phi might be assigned the same register
 * as the result of another phi, and the phi removal move scheduler may
 * generate moves that over-write the live result.
 *
 * @param ssaMeth {@code non-null;} method to process
 * @param interference {@code non-null;} interference graph
 */
private static void coInterferePhis(SsaMethod ssaMeth,
        InterferenceGraph interference) {
    for (SsaBasicBlock b : ssaMeth.getBlocks()) {
        List<SsaInsn> phis = b.getPhiInsns();

        int szPhis = phis.size();

        for (int i = 0; i < szPhis; i++) {
            for (int j = 0; j < szPhis; j++) {
                if (i == j) {
                    continue;
                }

                SsaInsn first = phis.get(i);
                SsaInsn second = phis.get(j);
                coInterferePhiRegisters(interference, first.getResult(), second.getSources());
                coInterferePhiRegisters(interference, second.getResult(), first.getSources());
                interference.add(first.getResult().getReg(), second.getResult().getReg());
            }
        }
    }
}
 

/**
 * Ensures that all the phi result registers for all the phis in the
 * same basic block interfere with each other. This is needed since
 * the dead code remover has allowed through "dead-end phis" whose
 * results are not used except as local assignments. Without this step,
 * a the result of a dead-end phi might be assigned the same register
 * as the result of another phi, and the phi removal move scheduler may
 * generate moves that over-write the live result.
 *
 * @param ssaMeth {@code non-null;} method to pricess
 * @param interference {@code non-null;} interference graph
 */
private static void coInterferePhis(SsaMethod ssaMeth,
        InterferenceGraph interference) {
    for (SsaBasicBlock b : ssaMeth.getBlocks()) {
        List<SsaInsn> phis = b.getPhiInsns();

        int szPhis = phis.size();

        for (int i = 0; i < szPhis; i++) {
            for (int j = 0; j < szPhis; j++) {
                if (i == j) {
                    continue;
                }

                interference.add(phis.get(i).getResult().getReg(),
                    phis.get(j).getResult().getReg());
            }
        }
    }
}
 

/**
 * Ensures that all the phi result registers for all the phis in the
 * same basic block interfere with each other. This is needed since
 * the dead code remover has allowed through "dead-end phis" whose
 * results are not used except as local assignments. Without this step,
 * a the result of a dead-end phi might be assigned the same register
 * as the result of another phi, and the phi removal move scheduler may
 * generate moves that over-write the live result.
 *
 * @param ssaMeth {@code non-null;} method to pricess
 * @param interference {@code non-null;} interference graph
 */
private static void coInterferePhis(SsaMethod ssaMeth,
        InterferenceGraph interference) {
    for (SsaBasicBlock b : ssaMeth.getBlocks()) {
        List<SsaInsn> phis = b.getPhiInsns();

        int szPhis = phis.size();

        for (int i = 0; i < szPhis; i++) {
            for (int j = 0; j < szPhis; j++) {
                if (i == j) {
                    continue;
                }

                interference.add(phis.get(i).getResult().getReg(),
                    phis.get(j).getResult().getReg());
            }
        }
    }
}
 

/**
 * Ensures that all the phi result registers for all the phis in the
 * same basic block interfere with each other, and also that a phi's source
 * registers interfere with the result registers from other phis. This is needed since
 * the dead code remover has allowed through "dead-end phis" whose
 * results are not used except as local assignments. Without this step,
 * a the result of a dead-end phi might be assigned the same register
 * as the result of another phi, and the phi removal move scheduler may
 * generate moves that over-write the live result.
 *
 * @param ssaMeth {@code non-null;} method to process
 * @param interference {@code non-null;} interference graph
 */
private static void coInterferePhis(SsaMethod ssaMeth,
        InterferenceGraph interference) {
    for (SsaBasicBlock b : ssaMeth.getBlocks()) {
        List<SsaInsn> phis = b.getPhiInsns();

        int szPhis = phis.size();

        for (int i = 0; i < szPhis; i++) {
            for (int j = 0; j < szPhis; j++) {
                if (i == j) {
                    continue;
                }

                SsaInsn first = phis.get(i);
                SsaInsn second = phis.get(j);
                coInterferePhiRegisters(interference, first.getResult(), second.getSources());
                coInterferePhiRegisters(interference, second.getResult(), first.getSources());
                interference.add(first.getResult().getReg(), second.getResult().getReg());
            }
        }
    }
}
 

/**
 * Runs register liveness algorithm for a method, updating the
 * live in/out information in {@code SsaBasicBlock} instances and
 * returning an interference graph.
 *
 * @param ssaMeth {@code non-null;} method to process
 * @return {@code non-null;} interference graph indexed by SSA
 * registers in both directions
 */
public static InterferenceGraph constructInterferenceGraph(
        SsaMethod ssaMeth) {
    int szRegs = ssaMeth.getRegCount();
    InterferenceGraph interference = new InterferenceGraph(szRegs);

    for (int i = 0; i < szRegs; i++) {
        new LivenessAnalyzer(ssaMeth, i, interference).run();
    }

    coInterferePhis(ssaMeth, interference);

    return interference;
}
 

/** {@inheritDoc} */
public FirstFitAllocator(
        final SsaMethod ssaMeth, final InterferenceGraph interference) {
    super(ssaMeth, interference);

    mapped = new BitSet(ssaMeth.getRegCount());
}
 

/**
 * Constructs instance.
 *
 * @param ssaMeth {@code non-null;} method to process
 * @param interference non-null interference graph for SSA registers
 * @param minimizeRegisters true if converter should take steps to
 * minimize rop-form registers
 */
public FirstFitLocalCombiningAllocator(
        SsaMethod ssaMeth, InterferenceGraph interference,
        boolean minimizeRegisters) {
    super(ssaMeth, interference);

    ssaRegsMapped = new BitSet(ssaMeth.getRegCount());

    mapper = new InterferenceRegisterMapper(
            interference, ssaMeth.getRegCount());

    this.minimizeRegisters = minimizeRegisters;

    /*
     * Reserve space for the params at the bottom of the register
     * space. Later, we'll flip the params to the end of the register
     * space.
     */

    paramRangeEnd = ssaMeth.getParamWidth();

    reservedRopRegs = new BitSet(paramRangeEnd * 2);
    reservedRopRegs.set(0, paramRangeEnd);
    usedRopRegs = new BitSet(paramRangeEnd * 2);
    localVariables = new TreeMap<LocalItem, ArrayList<RegisterSpec>>();
    moveResultPseudoInsns = new ArrayList<NormalSsaInsn>();
    invokeRangeInsns = new ArrayList<NormalSsaInsn>();
    phiInsns = new ArrayList<PhiInsn>();
}
 

/**
 * Makes liveness analyzer instance for specific register.
 *
 * @param ssaMeth {@code non-null;} method to process
 * @param reg register whose liveness to analyze
 * @param interference {@code non-null;} indexed by SSA reg in
 * both dimensions; graph to update
 *
 */
private LivenessAnalyzer(SsaMethod ssaMeth, int reg,
        InterferenceGraph interference) {
    int blocksSz = ssaMeth.getBlocks().size();

    this.ssaMeth = ssaMeth;
    this.regV = reg;
    visitedBlocks = new BitSet(blocksSz);
    liveOutBlocks = new BitSet(blocksSz);
    this.interference = interference;
}
 

/**
 * Runs register liveness algorithm for a method, updating the
 * live in/out information in {@code SsaBasicBlock} instances and
 * returning an interference graph.
 *
 * @param ssaMeth {@code non-null;} method to process
 * @return {@code non-null;} interference graph indexed by SSA
 * registers in both directions
 */
public static InterferenceGraph constructInterferenceGraph(
        SsaMethod ssaMeth) {
    int szRegs = ssaMeth.getRegCount();
    InterferenceGraph interference = new InterferenceGraph(szRegs);

    for (int i = 0; i < szRegs; i++) {
        new LivenessAnalyzer(ssaMeth, i, interference).run();
    }

    coInterferePhis(ssaMeth, interference);

    return interference;
}
 

/** {@inheritDoc} */
public FirstFitAllocator(
        final SsaMethod ssaMeth, final InterferenceGraph interference) {
    super(ssaMeth, interference);

    mapped = new BitSet(ssaMeth.getRegCount());
}
 

/**
   * Constructs instance.
   *
   * @param ssaMeth {@code non-null;} method to process
   * @param interference non-null interference graph for SSA registers
   * @param minimizeRegisters true if converter should take steps to
   * minimize rop-form registers
   */
  public FirstFitLocalCombiningAllocator(
          SsaMethod ssaMeth, InterferenceGraph interference,
          boolean minimizeRegisters) {
      super(ssaMeth, interference);

      ssaRegsMapped = new BitSet(ssaMeth.getRegCount());

      mapper = new InterferenceRegisterMapper(
              interference, ssaMeth.getRegCount());

/*
       * Reserve space for the params at the bottom of the register
       * space. Later, we'll flip the params to the end of the register
       * space.
       */

      paramRangeEnd = ssaMeth.getParamWidth();

      reservedRopRegs = new BitSet(paramRangeEnd * 2);
      reservedRopRegs.set(0, paramRangeEnd);
      usedRopRegs = new BitSet(paramRangeEnd * 2);
      localVariables = new TreeMap<LocalItem, ArrayList<RegisterSpec>>();
      moveResultPseudoInsns = new ArrayList<NormalSsaInsn>();
      invokeRangeInsns = new ArrayList<NormalSsaInsn>();
      phiInsns = new ArrayList<PhiInsn>();
  }
 

/**
 * Makes liveness analyzer instance for specific register.
 *
 * @param ssaMeth {@code non-null;} method to process
 * @param reg register whose liveness to analyze
 * @param interference {@code non-null;} indexed by SSA reg in
 * both dimensions; graph to update
 *
 */
private LivenessAnalyzer(SsaMethod ssaMeth, int reg,
        InterferenceGraph interference) {
    int blocksSz = ssaMeth.getBlocks().size();

    this.ssaMeth = ssaMeth;
    this.regV = reg;
    visitedBlocks = new BitSet(blocksSz);
    liveOutBlocks = new BitSet(blocksSz);
    this.interference = interference;
}
 

/**
 * Runs register liveness algorithm for a method, updating the
 * live in/out information in {@code SsaBasicBlock} instances and
 * returning an interference graph.
 *
 * @param ssaMeth {@code non-null;} method to process
 * @return {@code non-null;} interference graph indexed by SSA
 * registers in both directions
 */
public static InterferenceGraph constructInterferenceGraph(
        SsaMethod ssaMeth) {
    int szRegs = ssaMeth.getRegCount();
    InterferenceGraph interference = new InterferenceGraph(szRegs);

    for (int i = 0; i < szRegs; i++) {
        new LivenessAnalyzer(ssaMeth, i, interference).run();
    }

    coInterferePhis(ssaMeth, interference);

    return interference;
}
 

/** {@inheritDoc} */
public FirstFitAllocator(
        final SsaMethod ssaMeth, final InterferenceGraph interference) {
    super(ssaMeth, interference);

    mapped = new BitSet(ssaMeth.getRegCount());
}
 

/**
 * Makes liveness analyzer instance for specific register.
 *
 * @param ssaMeth {@code non-null;} method to process
 * @param reg register whose liveness to analyze
 * @param interference {@code non-null;} indexed by SSA reg in
 * both dimensions; graph to update
 *
 */
private LivenessAnalyzer(SsaMethod ssaMeth, int reg,
        InterferenceGraph interference) {
    int blocksSz = ssaMeth.getBlocks().size();

    this.ssaMeth = ssaMeth;
    this.regV = reg;
    visitedBlocks = new BitSet(blocksSz);
    liveOutBlocks = new BitSet(blocksSz);
    this.interference = interference;
}
 

/**
 * Constructs instance.
 *
 * @param ssaMeth {@code non-null;} method to process
 * @param interference non-null interference graph for SSA registers
 * @param minimizeRegisters true if converter should take steps to
 * minimize rop-form registers
 */
public FirstFitLocalCombiningAllocator(
        SsaMethod ssaMeth, InterferenceGraph interference,
        boolean minimizeRegisters) {
    super(ssaMeth, interference);

    ssaRegsMapped = new BitSet(ssaMeth.getRegCount());

    mapper = new InterferenceRegisterMapper(
            interference, ssaMeth.getRegCount());

    this.minimizeRegisters = minimizeRegisters;

    /*
     * Reserve space for the params at the bottom of the register
     * space. Later, we'll flip the params to the end of the register
     * space.
     */

    paramRangeEnd = ssaMeth.getParamWidth();

    reservedRopRegs = new BitSet(paramRangeEnd * 2);
    reservedRopRegs.set(0, paramRangeEnd);
    usedRopRegs = new BitSet(paramRangeEnd * 2);
    localVariables = new TreeMap<LocalItem, ArrayList<RegisterSpec>>();
    moveResultPseudoInsns = new ArrayList<NormalSsaInsn>();
    invokeRangeInsns = new ArrayList<NormalSsaInsn>();
    phiInsns = new ArrayList<PhiInsn>();
}
 

/**
 * Constructs instance.
 *
 * @param ssaMeth {@code non-null;} method to process
 * @param interference non-null interference graph for SSA registers
 * @param minimizeRegisters true if converter should take steps to
 * minimize rop-form registers
 */
public FirstFitLocalCombiningAllocator(
        SsaMethod ssaMeth, InterferenceGraph interference,
        boolean minimizeRegisters) {
    super(ssaMeth, interference);

    ssaRegsMapped = new BitSet(ssaMeth.getRegCount());

    mapper = new InterferenceRegisterMapper(
            interference, ssaMeth.getRegCount());

    this.minimizeRegisters = minimizeRegisters;

    /*
     * Reserve space for the params at the bottom of the register
     * space. Later, we'll flip the params to the end of the register
     * space.
     */

    paramRangeEnd = ssaMeth.getParamWidth();

    reservedRopRegs = new BitSet(paramRangeEnd * 2);
    reservedRopRegs.set(0, paramRangeEnd);
    usedRopRegs = new BitSet(paramRangeEnd * 2);
    localVariables = new TreeMap<LocalItem, ArrayList<RegisterSpec>>();
    moveResultPseudoInsns = new ArrayList<NormalSsaInsn>();
    invokeRangeInsns = new ArrayList<NormalSsaInsn>();
    phiInsns = new ArrayList<PhiInsn>();
}
 

/**
 * Makes liveness analyzer instance for specific register.
 *
 * @param ssaMeth {@code non-null;} method to process
 * @param reg register whose liveness to analyze
 * @param interference {@code non-null;} indexed by SSA reg in
 * both dimensions; graph to update
 *
 */
private LivenessAnalyzer(SsaMethod ssaMeth, int reg,
        InterferenceGraph interference) {
    int blocksSz = ssaMeth.getBlocks().size();

    this.ssaMeth = ssaMeth;
    this.regV = reg;
    visitedBlocks = new BitSet(blocksSz);
    liveOutBlocks = new BitSet(blocksSz);
    this.interference = interference;
}
 

/**
 * Runs register liveness algorithm for a method, updating the
 * live in/out information in {@code SsaBasicBlock} instances and
 * returning an interference graph.
 *
 * @param ssaMeth {@code non-null;} method to process
 * @return {@code non-null;} interference graph indexed by SSA
 * registers in both directions
 */
public static InterferenceGraph constructInterferenceGraph(
        SsaMethod ssaMeth) {
    int szRegs = ssaMeth.getRegCount();
    InterferenceGraph interference = new InterferenceGraph(szRegs);

    for (int i = 0; i < szRegs; i++) {
        new LivenessAnalyzer(ssaMeth, i, interference).run();
    }

    coInterferePhis(ssaMeth, interference);

    return interference;
}
 

/** {@inheritDoc} */
public FirstFitAllocator(
        final SsaMethod ssaMeth, final InterferenceGraph interference) {
    super(ssaMeth, interference);

    mapped = new BitSet(ssaMeth.getRegCount());
}
 

/** {@inheritDoc} */
public NullRegisterAllocator(SsaMethod ssaMeth,
        InterferenceGraph interference) {
    super(ssaMeth, interference);
}
 

/** {@inheritDoc} */
public NullRegisterAllocator(SsaMethod ssaMeth,
        InterferenceGraph interference) {
    super(ssaMeth, interference);
}
 

/** {@inheritDoc} */
public NullRegisterAllocator(SsaMethod ssaMeth,
        InterferenceGraph interference) {
    super(ssaMeth, interference);
}
 

/** {@inheritDoc} */
public NullRegisterAllocator(SsaMethod ssaMeth,
        InterferenceGraph interference) {
    super(ssaMeth, interference);
}
 

/**
 * Constructs an instance.
 *
 * @param ssaMeth {@code non-null;} method to process
 * @param minimizeRegisters {@code true} if the converter should
 * attempt to minimize the rop-form register count
 */
private SsaToRop(SsaMethod ssaMethod, boolean minimizeRegisters) {
    this.minimizeRegisters = minimizeRegisters;
    this.ssaMeth = ssaMethod;
    this.interference =
        LivenessAnalyzer.constructInterferenceGraph(ssaMethod);
}
 

/**
 * Constructs an instance.
 *
 * @param ssaMethod {@code non-null;} method to process
 * @param minimizeRegisters {@code true} if the converter should
 * attempt to minimize the rop-form register count
 */
private SsaToRop(SsaMethod ssaMethod, boolean minimizeRegisters) {
    this.minimizeRegisters = minimizeRegisters;
    this.ssaMeth = ssaMethod;
    this.interference =
        LivenessAnalyzer.constructInterferenceGraph(ssaMethod);
}
 

/**
 * Constructs an instance.
 *
 * @param ssaMeth {@code non-null;} method to process
 * @param minimizeRegisters {@code true} if the converter should
 * attempt to minimize the rop-form register count
 */
private SsaToRop(SsaMethod ssaMethod, boolean minimizeRegisters) {
    this.minimizeRegisters = minimizeRegisters;
    this.ssaMeth = ssaMethod;
    this.interference =
        LivenessAnalyzer.constructInterferenceGraph(ssaMethod);
}
 

/**
 * Constructs an instance.
 *
 * @param ssaMethod {@code non-null;} method to process
 * @param minimizeRegisters {@code true} if the converter should
 * attempt to minimize the rop-form register count
 */
private SsaToRop(SsaMethod ssaMethod, boolean minimizeRegisters) {
    this.minimizeRegisters = minimizeRegisters;
    this.ssaMeth = ssaMethod;
    this.interference =
        LivenessAnalyzer.constructInterferenceGraph(ssaMethod);
}
 

/**
 * Converts a method in SSA form to ROP form.
 *
 * @param ssaMeth {@code non-null;} method to process
 * @param minimizeRegisters {@code true} if the converter should
 * attempt to minimize the rop-form register count
 * @return {@code non-null;} rop-form output
 */
public static RopMethod convertToRopMethod(SsaMethod ssaMeth,
        boolean minimizeRegisters) {
    return new SsaToRop(ssaMeth, minimizeRegisters).convert();
}
 

/**
 * Converts a method in SSA form to ROP form.
 *
 * @param ssaMeth {@code non-null;} method to process
 * @param minimizeRegisters {@code true} if the converter should
 * attempt to minimize the rop-form register count
 * @return {@code non-null;} rop-form output
 */
public static RopMethod convertToRopMethod(SsaMethod ssaMeth,
        boolean minimizeRegisters) {
    return new SsaToRop(ssaMeth, minimizeRegisters).convert();
}