Java RegisterSpec.getCategory方法代码示例

import com.android.dx.rop.code.RegisterSpec; //导入方法依赖的package包/类
/**
 * Helper method to determine if a list of registers are sequential,
 * including degenerate cases for empty or single-element lists.
 *
 * @param list {@code non-null;} the list of registers
 * @return {@code true} iff the list is sequentially ordered
 */
protected static boolean isRegListSequential(RegisterSpecList list) {
    int sz = list.size();

    if (sz < 2) {
        return true;
    }

    int first = list.get(0).getReg();
    int next = first;

    for (int i = 0; i < sz; i++) {
        RegisterSpec one = list.get(i);
        if (one.getReg() != next) {
            return false;
        }
        next += one.getCategory();
    }

    return true;
}
 

import com.android.dx.rop.code.RegisterSpec; //导入方法依赖的package包/类
/**
 * Adds a mapping from an SSA register to a rop register.
 * {@link #canMapReg} should have already been called.
 *
 * @param ssaSpec {@code non-null;} SSA register to map from
 * @param ropReg {@code >=0;} rop register to map to
 */
private void addMapping(RegisterSpec ssaSpec, int ropReg) {
    int ssaReg = ssaSpec.getReg();

    // An assertion.
    if (ssaRegsMapped.get(ssaReg) || !canMapReg(ssaSpec, ropReg)) {
        throw new RuntimeException(
                "attempt to add invalid register mapping");
    }

    if (DEBUG) {
        System.out.printf("Add mapping s%d -> v%d c:%d\n",
                ssaSpec.getReg(), ropReg, ssaSpec.getCategory());
    }

    int category = ssaSpec.getCategory();
    mapper.addMapping(ssaSpec.getReg(), ropReg, category);
    ssaRegsMapped.set(ssaReg);
    usedRopRegs.set(ropReg, ropReg + category);
}
 

import com.android.dx.rop.code.RegisterSpec; //导入方法依赖的package包/类
/**
 * Makes a move instruction, appropriate and ideal for the given arguments.
 *
 * @param position {@code non-null;} source position information
 * @param dest {@code non-null;} destination register
 * @param src {@code non-null;} source register
 * @return {@code non-null;} an appropriately-constructed instance
 */
public static SimpleInsn makeMove(SourcePosition position,
        RegisterSpec dest, RegisterSpec src) {
    boolean category1 = dest.getCategory() == 1;
    boolean reference = dest.getType().isReference();
    int destReg = dest.getReg();
    int srcReg = src.getReg();
    Dop opcode;

    if ((srcReg | destReg) < 16) {
        opcode = reference ? Dops.MOVE_OBJECT :
            (category1 ? Dops.MOVE : Dops.MOVE_WIDE);
    } else if (destReg < 256) {
        opcode = reference ? Dops.MOVE_OBJECT_FROM16 :
            (category1 ? Dops.MOVE_FROM16 : Dops.MOVE_WIDE_FROM16);
    } else {
        opcode = reference ? Dops.MOVE_OBJECT_16 :
            (category1 ? Dops.MOVE_16 : Dops.MOVE_WIDE_16);
    }

    return new SimpleInsn(opcode, position,
                          RegisterSpecList.make(dest, src));
}
 

import com.android.dx.rop.code.RegisterSpec; //导入方法依赖的package包/类
/**
 * Checks to see if any of a set of old-namespace registers are
 * pinned to the specified new-namespace reg + category. Takes into
 * account the category of the old-namespace registers.
 *
 * @param oldSpecs {@code non-null;} set of old-namespace regs
 * @param newReg {@code >= 0;} new-namespace register
 * @param targetCategory {@code 1..2;} the number of adjacent new-namespace
 * registers (starting at ropReg) to consider
 * @return true if any of the old-namespace register have been mapped
 * to the new-namespace register + category
 */
public boolean areAnyPinned(RegisterSpecList oldSpecs,
        int newReg, int targetCategory) {
    int sz = oldSpecs.size();

    for (int i = 0; i < sz; i++) {
        RegisterSpec oldSpec = oldSpecs.get(i);
        int r = oldToNew(oldSpec.getReg());

        /*
         * If oldSpec is a category-2 register, then check both newReg
         * and newReg - 1.
         */
        if (r == newReg
            || (oldSpec.getCategory() == 2 && (r + 1) == newReg)
            || (targetCategory == 2 && (r == newReg + 1))) {
            return true;
        }
    }

    return false;
}
 

import com.android.dx.rop.code.RegisterSpec; //导入方法依赖的package包/类
/**
 * Helper for {@link #codeSize} and {@link #writeTo} which sets up
 * {@link #insns} if not already done.
 */
private void calculateInsnsIfNecessary() {
    if (insns != null) {
        return;
    }

    RegisterSpecList registers = getRegisters();
    int sz = registers.size();

    insns = new SimpleInsn[sz];

    for (int i = 0, outAt = 0; i < sz; i++) {
        RegisterSpec src = registers.get(i);
        insns[i] = moveInsnFor(src, outAt);
        outAt += src.getCategory();
    }
}
 

import com.android.dx.rop.code.RegisterSpec; //导入方法依赖的package包/类
/**
 * Maps all non-parameter, non-local variable registers.
 */
private void handleNormalUnassociated() {
    int szSsaRegs = ssaMeth.getRegCount();

    for (int ssaReg = 0; ssaReg < szSsaRegs; ssaReg++) {
        if (ssaRegsMapped.get(ssaReg)) {
            // We already did this one
            continue;
        }

        RegisterSpec ssaSpec = getDefinitionSpecForSsaReg(ssaReg);

        if (ssaSpec == null) continue;

        int category = ssaSpec.getCategory();
        // Find a rop reg that does not interfere
        int ropReg = findNextUnreservedRopReg(paramRangeEnd, category);
        while (!canMapReg(ssaSpec, ropReg)) {
            ropReg = findNextUnreservedRopReg(ropReg + 1, category);
        }

        addMapping(ssaSpec, ropReg);
    }
}
 

import com.android.dx.rop.code.RegisterSpec; //导入方法依赖的package包/类
/** {@inheritDoc} */
@Override
protected String listingString0(boolean noteIndices) {
    RegisterSpecList registers = getRegisters();
    int sz = registers.size();
    StringBuffer sb = new StringBuffer(100);

    for (int i = 0, outAt = 0; i < sz; i++) {
        RegisterSpec src = registers.get(i);
        SimpleInsn insn = moveInsnFor(src, outAt);

        if (i != 0) {
            sb.append('\n');
        }

        sb.append(insn.listingString0(noteIndices));

        outAt += src.getCategory();
    }

    return sb.toString();
}
 

import com.android.dx.rop.code.RegisterSpec; //导入方法依赖的package包/类
/**
 * Gets the number of words required for the given register list, where
 * category-2 values count as two words. Return {@code -1} if the
 * list requires more than five words or contains registers that need
 * more than a nibble to identify them.
 *
 * @param regs {@code non-null;} the register list in question
 * @return {@code >= -1;} the number of words required, or {@code -1}
 * if the list couldn't possibly fit in this format
 */
private static int wordCount(RegisterSpecList regs) {
    int sz = regs.size();

    if (sz > MAX_NUM_OPS) {
        // It can't possibly fit.
        return -1;
    }

    int result = 0;

    for (int i = 0; i < sz; i++) {
        RegisterSpec one = regs.get(i);
        result += one.getCategory();
        /*
         * The check below adds (category - 1) to the register, to
         * account for the fact that the second half of a
         * category-2 register has to be represented explicitly in
         * the result.
         */
        if (!unsignedFitsInNibble(one.getReg() + one.getCategory() - 1)) {
            return -1;
        }
    }

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

import com.android.dx.rop.code.RegisterSpec; //导入方法依赖的package包/类
/**
 * Returns a register list which is equivalent to the given one,
 * except that it splits category-2 registers into two explicit
 * entries. This returns the original list if no modification is
 * required
 *
 * @param orig {@code non-null;} the original list
 * @return {@code non-null;} the list with the described transformation
 */
private static RegisterSpecList explicitize(RegisterSpecList orig) {
    int wordCount = wordCount(orig);
    int sz = orig.size();

    if (wordCount == sz) {
        return orig;
    }

    RegisterSpecList result = new RegisterSpecList(wordCount);
    int wordAt = 0;

    for (int i = 0; i < sz; i++) {
        RegisterSpec one = orig.get(i);
        result.set(wordAt, one);
        if (one.getCategory() == 2) {
            result.set(wordAt + 1,
                       RegisterSpec.make(one.getReg() + 1, Type.VOID));
            wordAt += 2;
        } else {
            wordAt++;
        }
    }

    result.setImmutable();
    return result;
}
 

import com.android.dx.rop.code.RegisterSpec; //导入方法依赖的package包/类
/**
 * Helper method to return a register range string.
 *
 * @param list {@code non-null;} the list of registers (which must be
 * sequential)
 * @return {@code non-null;} the string form
 */
protected static String regRangeString(RegisterSpecList list) {
    int size = list.size();
    StringBuilder sb = new StringBuilder(30);

    sb.append("{");

    switch (size) {
        case 0: {
            // Nothing to do.
            break;
        }
        case 1: {
            sb.append(list.get(0).regString());
            break;
        }
        default: {
            RegisterSpec lastReg = list.get(size - 1);
            if (lastReg.getCategory() == 2) {
                /*
                 * Add one to properly represent a list-final
                 * category-2 register.
                 */
                lastReg = lastReg.withOffset(1);
            }

            sb.append(list.get(0).regString());
            sb.append("..");
            sb.append(lastReg.regString());
        }
    }

    sb.append("}");

    return sb.toString();
}
 

import com.android.dx.rop.code.RegisterSpec; //导入方法依赖的package包/类
/**
 * Tries to map an SSA register to a rop register.
 *
 * @param ssaSpec {@code non-null;} SSA register
 * @param ropReg {@code >=0;} rop register
 * @param maxAllowedCategory {@code 1..2;} the maximum category
 * that the SSA register is allowed to be
 * @return {@code true} if map succeeded, {@code false} if not
 */
private boolean tryMapReg(RegisterSpec ssaSpec, int ropReg,
        int maxAllowedCategory) {
    if (ssaSpec.getCategory() <= maxAllowedCategory
            && !ssaRegsMapped.get(ssaSpec.getReg())
            && canMapReg(ssaSpec, ropReg)) {
        addMapping(ssaSpec, ropReg);
        return true;
    }

    return false;
}
 

import com.android.dx.rop.code.RegisterSpec; //导入方法依赖的package包/类
/**
 * Maps all local-associated parameters to rop registers.
 */
private void handleLocalAssociatedParams() {
    for (ArrayList<RegisterSpec> ssaRegs : localVariables.values()) {
        int sz = ssaRegs.size();
        int paramIndex = -1;
        int paramCategory = 0;

        // First, find out if this local variable is a parameter.
        for (int i = 0; i < sz; i++) {
            RegisterSpec ssaSpec = ssaRegs.get(i);
            int ssaReg = ssaSpec.getReg();

            paramIndex = getParameterIndexForReg(ssaReg);

            if (paramIndex >= 0) {
                paramCategory = ssaSpec.getCategory();
                addMapping(ssaSpec, paramIndex);
                break;
            }
        }

        if (paramIndex < 0) {
            // This local wasn't a parameter.
            continue;
        }

        // Any remaining local-associated registers will be mapped later.
        tryMapRegs(ssaRegs, paramIndex, paramCategory, true);
    }
}
 

import com.android.dx.rop.code.RegisterSpec; //导入方法依赖的package包/类
/**
 * Attempts to map the sources and result of a phi to a common register.
 * Will try existing mappings first, from most to least common. If none
 * of the registers have mappings yet, a new mapping is created.
 */
private void processPhiInsn(PhiInsn insn) {
    RegisterSpec result = insn.getResult();
    int resultReg = result.getReg();
    int category = result.getCategory();

    RegisterSpecList sources = insn.getSources();
    int sourcesSize = sources.size();

    // List of phi sources / result that need mapping
    ArrayList<RegisterSpec> ssaRegs = new ArrayList<RegisterSpec>();

    // Track how many times a particular mapping is found
    Multiset mapSet = new Multiset(sourcesSize + 1);

    /*
     * If the result of the phi has an existing mapping, get it.
     * Otherwise, add it to the list of regs that need mapping.
     */
    if (ssaRegsMapped.get(resultReg)) {
        mapSet.add(mapper.oldToNew(resultReg));
    } else {
        ssaRegs.add(result);
    }

    for (int i = 0; i < sourcesSize; i++) {
        RegisterSpec source = sources.get(i);
        SsaInsn def = ssaMeth.getDefinitionForRegister(source.getReg());
        RegisterSpec sourceDef = def.getResult();
        int sourceReg = sourceDef.getReg();

        /*
         * If a source of the phi has an existing mapping, get it.
         * Otherwise, add it to the list of regs that need mapping.
         */
        if (ssaRegsMapped.get(sourceReg)) {
            mapSet.add(mapper.oldToNew(sourceReg));
        } else {
            ssaRegs.add(sourceDef);
        }
    }

    // Try all existing mappings, with the most common ones first
    for (int i = 0; i < mapSet.getSize(); i++) {
        int maxReg = mapSet.getAndRemoveHighestCount();
        tryMapRegs(ssaRegs, maxReg, category, false);
    }

    // Map any remaining unmapped regs with whatever fits
    int mapReg = findNextUnreservedRopReg(paramRangeEnd, category);
    while (!tryMapRegs(ssaRegs, mapReg, category, false)) {
        mapReg = findNextUnreservedRopReg(mapReg + 1, category);
    }
}
 

import com.android.dx.rop.code.RegisterSpec; //导入方法依赖的package包/类
/**
 * Sets the register as used in a bitset, taking into account its
 * category/width.
 *
 * @param regsUsed set, indexed by register number
 * @param rs register to mark as used
 */
private static void setRegsUsed (BitSet regsUsed, RegisterSpec rs) {
    regsUsed.set(rs.getReg());
    if (rs.getCategory() > 1) {
        regsUsed.set(rs.getReg() + 1);
    }
}
 

import com.android.dx.rop.code.RegisterSpec; //导入方法依赖的package包/类
/**
 * Checks to see if the register is used in a bitset, taking
 * into account its category/width.
 *
 * @param regsUsed set, indexed by register number
 * @param rs register to mark as used
 * @return true if register is fully or partially (for the case of wide
 * registers) used.
 */
private static boolean checkRegUsed (BitSet regsUsed, RegisterSpec rs) {
    int reg = rs.getReg();
    int category = rs.getCategory();

    return regsUsed.get(reg)
            || (category == 2 ? regsUsed.get(reg + 1) : false);
}