import com.android.dx.util.IntList; //导入依赖的package包/类
/**
 * Combines blocks proven identical into one alpha block, re-writing
 * all of the successor links that point to the beta blocks to point
 * to the alpha block instead.
 *
 * @param alphaLabel block that will replace all the beta block
 * @param betaLabels label list of blocks to combine
 */
private void combineBlocks(int alphaLabel, IntList betaLabels) {
    int szBetas = betaLabels.size();

    for (int i = 0; i < szBetas; i++) {
        int betaLabel = betaLabels.get(i);
        BasicBlock bb = blocks.labelToBlock(betaLabel);
        IntList preds = ropMethod.labelToPredecessors(bb.getLabel());
        int szPreds = preds.size();

        for (int j = 0; j < szPreds; j++) {
            BasicBlock predBlock = newBlocks.labelToBlock(preds.get(j));
            replaceSucc(predBlock, betaLabel, alphaLabel);
        }
    }
}
 

import com.android.dx.util.IntList; //导入依赖的package包/类
/**
 * Determines whether the given list of cases warrant being packed.
 *
 * @param cases {@code non-null;} sorted list of cases
 * @return {@code true} iff the table encoding the cases
 * should be packed
 */
private static boolean shouldPack(IntList cases) {
    int sz = cases.size();

    if (sz < 2) {
        return true;
    }

    long packedSize = packedCodeSize(cases);
    long sparseSize = sparseCodeSize(cases);

    /*
     * We pick the packed representation if it is possible and
     * would be as small or smaller than 5/4 of the sparse
     * representation. That is, we accept some size overhead on
     * the packed representation, since that format is faster to
     * execute at runtime.
     */
    return (packedSize >= 0) && (packedSize <= ((sparseSize * 5) / 4));
}
 

import com.android.dx.util.IntList; //导入依赖的package包/类
/**
 * Constructs an instance. This class is not publicly instantiable; use
 * {@link #identifyBlocks}.
 *
 * @param method {@code non-null;} method to convert
 */
private BasicBlocker(ConcreteMethod method) {
    if (method == null) {
        throw new NullPointerException("method == null");
    }

    this.method = method;

    /*
     * The "+1" below is so the idx-past-end is also valid,
     * avoiding a special case, but without preventing
     * flow-of-control falling past the end of the method from
     * getting properly reported.
     */
    int sz = method.getCode().size() + 1;

    workSet = Bits.makeBitSet(sz);
    liveSet = Bits.makeBitSet(sz);
    blockSet = Bits.makeBitSet(sz);
    targetLists = new IntList[sz];
    catchLists = new ByteCatchList[sz];
    previousOffset = -1;
}
 

import com.android.dx.util.IntList; //导入依赖的package包/类
/**
 * Constructs an instance.
 *
 * @param locals {@code non-null;} the locals array to use
 * @param stack {@code non-null;} the execution stack to use
 * @param subroutines {@code non-null;} list of subroutine start labels for
 * subroutines this frame is nested in
 */
private Frame(LocalsArray locals,
        ExecutionStack stack, IntList subroutines) {
    if (locals == null) {
        throw new NullPointerException("locals == null");
    }

    if (stack == null) {
        throw new NullPointerException("stack == null");
    }

    subroutines.throwIfMutable();

    this.locals = locals;
    this.stack = stack;
    this.subroutines = subroutines;
}
 

import com.android.dx.util.IntList; //导入依赖的package包/类
/**
 * Merges two frames. If the merged result is the same as this frame,
 * then this instance is returned.
 *
 * @param other {@code non-null;} another frame
 * @return {@code non-null;} the result of merging the two frames
 */
public Frame mergeWith(Frame other) {
    LocalsArray resultLocals;
    ExecutionStack resultStack;
    IntList resultSubroutines;

    resultLocals = getLocals().merge(other.getLocals());
    resultStack = getStack().merge(other.getStack());
    resultSubroutines = mergeSubroutineLists(other.subroutines);

    resultLocals = adjustLocalsForSubroutines(
            resultLocals, resultSubroutines);

    if ((resultLocals == getLocals())
            && (resultStack == getStack())
            && subroutines == resultSubroutines) {
        return this;
    }

    return new Frame(resultLocals, resultStack, resultSubroutines);
}
 

import com.android.dx.util.IntList; //导入依赖的package包/类
/**
 * Merges this frame's subroutine lists with another. The result
 * is the deepest common nesting (effectively, the common prefix of the
 * two lists).
 *
 * @param otherSubroutines label list of subroutine start blocks, from
 * least-nested to most-nested.
 * @return {@code non-null;} merged subroutine nest list as described above
 */
private IntList mergeSubroutineLists(IntList otherSubroutines) {
    if (subroutines.equals(otherSubroutines)) {
        return subroutines;
    }

    IntList resultSubroutines = new IntList();

    int szSubroutines = subroutines.size();
    int szOthers = otherSubroutines.size();
    for (int i = 0; i < szSubroutines && i < szOthers
            && (subroutines.get(i) == otherSubroutines.get(i)); i++) {
        resultSubroutines.add(i);
    }

    resultSubroutines.setImmutable();

    return resultSubroutines;
}
 

import com.android.dx.util.IntList; //导入依赖的package包/类
/**
 * Generates a list of subroutine successors. Note: successor blocks
 * could be listed more than once. This is ok, because this successor
 * list (and the block it's associated with) will be copied and inlined
 * before we leave the ropper. Redundent successors will result in
 * redundent (no-op) merges.
 *
 * @return all currently known successors
 * (return destinations) for that subroutine
 */
IntList getSuccessors() {
    IntList successors = new IntList(callerBlocks.size());

    /*
     * For each subroutine caller, get it's target. If the
     * target is us, add the ret target (subroutine successor)
     * to our list
     */

    for (int label = callerBlocks.nextSetBit(0); label >= 0;
         label = callerBlocks.nextSetBit(label+1)) {
        BasicBlock subCaller = labelToBlock(label);
        successors.add(subCaller.getSuccessors().get(0));
    }

    successors.setImmutable();

    return successors;
}
 

import com.android.dx.util.IntList; //导入依赖的package包/类
/**
 * Adds or replaces a block in the output result. Do not delete
 * any successors.
 *
 * @param block {@code non-null;} the block to add or replace
 * @param subroutines {@code non-null;} subroutine label list
 * as described in {@link Frame#getSubroutines}
 * @return {@code true} if the block was replaced or
 * {@code false} if it was added for the first time
 */
private boolean addOrReplaceBlockNoDelete(BasicBlock block,
        IntList subroutines) {
    if (block == null) {
        throw new NullPointerException("block == null");
    }

    int idx = labelToResultIndex(block.getLabel());
    boolean ret;

    if (idx < 0) {
        ret = false;
    } else {
        result.remove(idx);
        resultSubroutines.remove(idx);
        ret = true;
    }

    result.add(block);
    subroutines.throwIfMutable();
    resultSubroutines.add(subroutines);
    return ret;
}
 

import com.android.dx.util.IntList; //导入依赖的package包/类
/**
 * Deletes all blocks that cannot be reached. This is run to delete
 * original subroutine blocks after subroutine inlining.
 */
private void deleteUnreachableBlocks() {
    final IntList reachableLabels = new IntList(result.size());

    // subroutine inlining is done now and we won't update this list here
    resultSubroutines.clear();

    forEachNonSubBlockDepthFirst(getSpecialLabel(PARAM_ASSIGNMENT),
            new BasicBlock.Visitor() {

        public void visitBlock(BasicBlock b) {
            reachableLabels.add(b.getLabel());
        }
    });

    reachableLabels.sort();

    for (int i = result.size() - 1 ; i >= 0 ; i--) {
        if (reachableLabels.indexOf(result.get(i).getLabel()) < 0) {
            result.remove(i);
            // unnecessary here really, since subroutine inlining is done
            //resultSubroutines.remove(i);
        }
    }
}
 

import com.android.dx.util.IntList; //导入依赖的package包/类
/**
 * Gets the preferred successor for the given block. If the block
 * only has one successor, then that is the preferred successor.
 * Otherwise, if the block has a primay successor, then that is
 * the preferred successor. If the block has no successors, then
 * this returns {@code null}.
 *
 * @param block {@code non-null;} the block in question
 * @return {@code null-ok;} the preferred successor, if any
 */
public BasicBlock preferredSuccessorOf(BasicBlock block) {
    int primarySuccessor = block.getPrimarySuccessor();
    IntList successors = block.getSuccessors();
    int succSize = successors.size();

    switch (succSize) {
        case 0: {
            return null;
        }
        case 1: {
            return labelToBlock(successors.get(0));
        }
    }

    if (primarySuccessor != -1) {
        return labelToBlock(primarySuccessor);
    } else {
        return labelToBlock(successors.get(0));
    }
}
 

import com.android.dx.util.IntList; //导入依赖的package包/类
/**
 * Replaces one of a block's successors with a different label. Constructs
 * an updated BasicBlock instance and places it in {@code newBlocks}.
 *
 * @param block block to replace
 * @param oldLabel label of successor to replace
 * @param newLabel label of new successor
 */
private void replaceSucc(BasicBlock block, int oldLabel, int newLabel) {
    IntList newSuccessors = block.getSuccessors().mutableCopy();
    int newPrimarySuccessor;

    newSuccessors.set(newSuccessors.indexOf(oldLabel), newLabel);
    newPrimarySuccessor = block.getPrimarySuccessor();

    if (newPrimarySuccessor == oldLabel) {
        newPrimarySuccessor = newLabel;
    }

    newSuccessors.setImmutable();

    BasicBlock newBB = new BasicBlock(block.getLabel(),
            block.getInsns(), newSuccessors, newPrimarySuccessor);

    newBlocks.set(newBlocks.indexOfLabel(block.getLabel()), newBB);
}
 

import com.android.dx.util.IntList; //导入依赖的package包/类
/**
 * Constructs an instance. The output address of this instance is initially
 * unknown ({@code -1}).
 *
 * @param position {@code non-null;} source position
 * @param user {@code non-null;} address representing the instruction that
 * uses this instance
 * @param cases {@code non-null;} sorted list of switch cases (keys)
 * @param targets {@code non-null;} corresponding list of code addresses; the
 * branch target for each case
 */
public SwitchData(SourcePosition position, CodeAddress user,
                  IntList cases, CodeAddress[] targets) {
    super(position, RegisterSpecList.EMPTY);

    if (user == null) {
        throw new NullPointerException("user == null");
    }

    if (cases == null) {
        throw new NullPointerException("cases == null");
    }

    if (targets == null) {
        throw new NullPointerException("targets == null");
    }

    int sz = cases.size();

    if (sz != targets.length) {
        throw new IllegalArgumentException("cases / targets mismatch");
    }

    if (sz > 65535) {
        throw new IllegalArgumentException("too many cases");
    }

    this.user = user;
    this.cases = cases;
    this.targets = targets;
    this.packed = shouldPack(cases);
}
 

import com.android.dx.util.IntList; //导入依赖的package包/类
/**
 * Gets the size of a packed table for the given cases, in 16-bit code
 * units.
 *
 * @param cases {@code non-null;} sorted list of cases
 * @return {@code >= -1;} the packed table size or {@code -1} if the
 * cases couldn't possibly be represented as a packed table
 */
private static long packedCodeSize(IntList cases) {
    int sz = cases.size();
    long low = cases.get(0);
    long high = cases.get(sz - 1);
    long result = ((high - low + 1)) * 2 + 4;

    return (result <= 0x7fffffff) ? result : -1;
}
 

import com.android.dx.util.IntList; //导入依赖的package包/类
/**
 * Builds an IntList of block indices from a basic block list and a list
 * of labels taken from Rop form.
 *
 * @param ropBlocks Rop blocks
 * @param labelList list of rop block labels
 * @return IntList of block indices
 */
public static IntList indexListFromLabelList(BasicBlockList ropBlocks,
        IntList labelList) {

    IntList result = new IntList(labelList.size());

    for (int i = 0, sz = labelList.size(); i < sz; i++) {
        result.add(ropBlocks.indexOfLabel(labelList.get(i)));
    }

    return result;
}
 

import com.android.dx.util.IntList; //导入依赖的package包/类
/**
 * Constructs an instance.
 *
 * @param size {@code >= 0;} the number of elements to be in the table
 */
public SwitchList(int size) {
    super(true);
    this.values = new IntList(size);
    this.targets = new IntList(size + 1);
    this.size = size;
}
 

import com.android.dx.util.IntList; //导入依赖的package包/类
/**
 * Adds a block to the output result.
 *
 * @param block {@code non-null;} the block to add
 * @param subroutines {@code non-null;} subroutine label list
 * as described in {@link Frame#getSubroutines}
 */
private void addBlock(BasicBlock block, IntList subroutines) {
    if (block == null) {
        throw new NullPointerException("block == null");
    }

    result.add(block);
    subroutines.throwIfMutable();
    resultSubroutines.add(subroutines);
}
 

import com.android.dx.util.IntList; //导入依赖的package包/类
/**
 * Constructs an instance.
 *
 * @param opcode {@code non-null;} the opcode
 * @param position {@code non-null;} source position
 * @param result {@code null-ok;} spec for the result, if any
 * @param sources {@code non-null;} specs for all the sources
 * @param cases {@code non-null;} list of switch cases
 */
public SwitchInsn(Rop opcode, SourcePosition position, RegisterSpec result,
                  RegisterSpecList sources, IntList cases) {
    super(opcode, position, result, sources);

    if (opcode.getBranchingness() != Rop.BRANCH_SWITCH) {
        throw new IllegalArgumentException("bogus branchingness");
    }

    if (cases == null) {
        throw new NullPointerException("cases == null");
    }

    this.cases = cases;
}
 

import com.android.dx.util.IntList; //导入依赖的package包/类
/**
 * Returns a target list corresponding to this instance. The result
 * is a list of all the exception handler addresses, with the given
 * {@code noException} address appended if appropriate. The
 * result is automatically made immutable.
 *
 * @param noException {@code >= -1;} the no-exception address to append, or
 * {@code -1} not to append anything
 * @return {@code non-null;} list of exception targets, with
 * {@code noException} appended if necessary
 */
public IntList toTargetList(int noException) {
    if (noException < -1) {
        throw new IllegalArgumentException("noException < -1");
    }

    boolean hasDefault = (noException >= 0);
    int sz = size();

    if (sz == 0) {
        if (hasDefault) {
            /*
             * The list is empty, but there is a no-exception
             * address; so, the result is just that address.
             */
            return IntList.makeImmutable(noException);
        }
        /*
         * The list is empty and there isn't even a no-exception
         * address.
         */
        return IntList.EMPTY;
    }

    IntList result = new IntList(sz + (hasDefault ? 1 : 0));

    for (int i = 0; i < sz; i++) {
        result.add(get(i).getHandlerPc());
    }

    if (hasDefault) {
        result.add(noException);
    }

    result.setImmutable();
    return result;
}
 

import com.android.dx.util.IntList; //导入依赖的package包/类
/** {@inheritDoc} */
public void visitLocal(int opcode, int offset, int length,
        int idx, Type type, int value) {
    if (opcode == ByteOps.RET) {
        visitCommon(offset, length, false);
        targetLists[offset] = IntList.EMPTY;
    } else {
        visitCommon(offset, length, true);
    }
}
 

import com.android.dx.util.IntList; //导入依赖的package包/类
/** {@inheritDoc} */
public void visitBranch(int opcode, int offset, int length,
        int target) {
    switch (opcode) {
        case ByteOps.GOTO: {
            visitCommon(offset, length, false);
            targetLists[offset] = IntList.makeImmutable(target);
            break;
        }
        case ByteOps.JSR: {
            /*
             * Each jsr is quarantined into a separate block (containing
             * only the jsr instruction) but is otherwise treated
             * as a conditional branch. (That is to say, both its
             * target and next instruction begin new blocks.)
             */
            addWorkIfNecessary(offset, true);
            // Fall through to next case...
        }
        default: {
            int next = offset + length;
            visitCommon(offset, length, true);
            addWorkIfNecessary(next, true);
            targetLists[offset] = IntList.makeImmutable(next, target);
            break;
        }
    }

    addWorkIfNecessary(target, true);
}