FileDocCategorySizeDatePackage
DalvInsn.javaAPI DocAndroid 5.1 API15286Thu Mar 12 22:18:30 GMT 2015com.android.dx.dex.code

DalvInsn

public abstract class DalvInsn extends Object
Base class for Dalvik instructions.

Fields Summary
private int
address
the actual output address of this instance, if known, or {@code -1} if not
private final Dop
opcode
the opcode; one of the constants from {@link Dops}
private final com.android.dx.rop.code.SourcePosition
position
{@code non-null;} source position
private final com.android.dx.rop.code.RegisterSpecList
registers
{@code non-null;} list of register arguments
Constructors Summary
public DalvInsn(Dop opcode, com.android.dx.rop.code.SourcePosition position, com.android.dx.rop.code.RegisterSpecList registers)
Constructs an instance. The output address of this instance is initially unknown ({@code -1}).

Note: In the unlikely event that an instruction takes absolutely no registers (e.g., a {@code nop} or a no-argument no-result static method call), then the given register list may be passed as {@link RegisterSpecList#EMPTY}.

param
opcode the opcode; one of the constants from {@link Dops}
param
position {@code non-null;} source position
param
registers {@code non-null;} register list, including a result register if appropriate (that is, registers may be either ins and outs)

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

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

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

        this.address = -1;
        this.opcode = opcode;
        this.position = position;
        this.registers = registers;
    
Methods Summary
protected abstract java.lang.StringargString()
Gets the string form for any arguments to this instance. Subclasses must override this.

return
{@code null-ok;} the string version of any arguments or {@code null} if there are none

public abstract intcodeSize()
Gets the size of this instruction, in 16-bit code units.

return
{@code >= 0;} the code size of this instruction

public com.android.dx.dex.code.DalvInsnexpandedPrefix(java.util.BitSet compatRegs)
Gets the instruction prefix required, if any, to use in an expanded version of this instance. Will not generate moves for registers marked compatible to the format by the given BitSet.

see
#expandedVersion
param
compatRegs {@code non-null;} set of compatible registers
return
{@code null-ok;} the prefix, if any

        RegisterSpecList regs = registers;
        boolean firstBit = compatRegs.get(0);

        if (hasResult()) compatRegs.set(0);

        regs = regs.subset(compatRegs);

        if (hasResult()) compatRegs.set(0, firstBit);

        if (regs.size() == 0) return null;

        return new HighRegisterPrefix(position, regs);
    
public com.android.dx.dex.code.DalvInsnexpandedSuffix(java.util.BitSet compatRegs)
Gets the instruction suffix required, if any, to use in an expanded version of this instance. Will not generate a move for a register marked compatible to the format by the given BitSet.

see
#expandedVersion
param
compatRegs {@code non-null;} set of compatible registers
return
{@code null-ok;} the suffix, if any

        if (hasResult() && !compatRegs.get(0)) {
            RegisterSpec r = registers.get(0);
            return makeMove(position, r, r.withReg(0));
        } else {
            return null;
        }
    
public com.android.dx.dex.code.DalvInsnexpandedVersion(java.util.BitSet compatRegs)
Gets the instruction that is equivalent to this one, except that it replaces incompatible registers with sequential registers starting at {@code 0} (storing the result, if any, in register {@code 0} as well). The sequence of instructions from {@link #expandedPrefix} and {@link #expandedSuffix} (if non-null) surrounding the result of a call to this method are the expanded transformation of this instance, and it is guaranteed that the number of low registers used will be the number returned by {@link #getMinimumRegisterRequirement}.

param
compatRegs {@code non-null;} set of compatible registers
return
{@code non-null;} the replacement

        RegisterSpecList regs =
            registers.withExpandedRegisters(0, hasResult(), compatRegs);
        return withRegisters(regs);
    
public final intgetAddress()
Gets the output address of this instruction, if it is known. This throws a {@code RuntimeException} if it has not yet been set.

see
#setAddress
return
{@code >= 0;} the output address

        if (address < 0) {
            throw new RuntimeException("address not yet known");
        }

        return address;
    
public com.android.dx.dex.code.DalvInsngetLowRegVersion()
Gets the instruction that is equivalent to this one, except that it uses sequential registers starting at {@code 0} (storing the result, if any, in register {@code 0} as well).

return
{@code non-null;} the replacement

        RegisterSpecList regs =
            registers.withExpandedRegisters(0, hasResult(), null);
        return withRegisters(regs);
    
public final intgetMinimumRegisterRequirement(java.util.BitSet compatRegs)
Gets the minimum distinct registers required for this instruction. Uses the given BitSet to determine which registers require replacement, and ignores registers that are already compatible. This assumes that the result (if any) can share registers with the sources (if any), that each source register is unique, and that (to be explicit here) category-2 values take up two consecutive registers.

param
compatRegs {@code non-null;} set of compatible registers
return
{@code >= 0;} the minimum distinct register requirement

        boolean hasResult = hasResult();
        int regSz = registers.size();
        int resultRequirement = 0;
        int sourceRequirement = 0;

        if (hasResult && !compatRegs.get(0)) {
            resultRequirement = registers.get(0).getCategory();
        }

        for (int i = hasResult ? 1 : 0; i < regSz; i++) {
            if (!compatRegs.get(i)) {
                sourceRequirement += registers.get(i).getCategory();
            }
        }

        return Math.max(sourceRequirement, resultRequirement);
    
public final intgetNextAddress()
Gets the address immediately after this instance. This is only calculable if this instance's address is known, and it is equal to the address plus the length of the instruction format of this instance's opcode.

return
{@code >= 0;} the next address

        return getAddress() + codeSize();
    
public final DopgetOpcode()
Gets the opcode.

return
{@code non-null;} the opcode

        return opcode;
    
public final com.android.dx.rop.code.SourcePositiongetPosition()
Gets the source position.

return
{@code non-null;} the source position

        return position;
    
public final com.android.dx.rop.code.RegisterSpecListgetRegisters()
Gets the register list for this instruction.

return
{@code non-null;} the registers

        return registers;
    
public final booleanhasAddress()
Gets whether the address of this instruction is known.

see
#getAddress
see
#setAddress

        return (address >= 0);
    
public final booleanhasResult()
Returns whether this instance's opcode uses a result register. This method is a convenient shorthand for {@code getOpcode().hasResult()}.

return
{@code true} iff this opcode uses a result register

        return opcode.hasResult();
    
public final java.lang.StringidentifierString()
Gets the short identifier for this instruction. This is its address, if assigned, or its identity hashcode if not.

return
{@code non-null;} the identifier

        if (address != -1) {
            return String.format("%04x", address);
        }

        return Hex.u4(System.identityHashCode(this));
    
public final java.lang.StringlistingString(java.lang.String prefix, int width, boolean noteIndices)
Returns the string form of this instance suitable for inclusion in a human-oriented listing dump. This method will return {@code null} if this instance should not appear in a listing.

param
prefix {@code non-null;} prefix before the address; each follow-on line will be indented to match as well
param
width {@code >= 0;} the width of the output or {@code 0} for unlimited width
param
noteIndices whether to include an explicit notation of constant pool indices
return
{@code null-ok;} the string form or {@code null} if this instance should not appear in a listing

        String insnPerSe = listingString0(noteIndices);

        if (insnPerSe == null) {
            return null;
        }

        String addr = prefix + identifierString() + ": ";
        int w1 = addr.length();
        int w2 = (width == 0) ? insnPerSe.length() : (width - w1);

        return TwoColumnOutput.toString(addr, w1, "", insnPerSe, w2);
    
protected abstract java.lang.StringlistingString0(boolean noteIndices)
Helper for {@link #listingString}, which returns the string form of this instance suitable for inclusion in a human-oriented listing dump, not including the instruction address and without respect for any output formatting. This method should return {@code null} if this instance should not appear in a listing.

param
noteIndices whether to include an explicit notation of constant pool indices
return
{@code null-ok;} the listing string

public static SimpleInsnmakeMove(com.android.dx.rop.code.SourcePosition position, com.android.dx.rop.code.RegisterSpec dest, com.android.dx.rop.code.RegisterSpec src)
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

        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));
    
public final voidsetAddress(int address)
Sets the output address.

param
address {@code >= 0;} the output address

        if (address < 0) {
            throw new IllegalArgumentException("address < 0");
        }

        this.address = address;
    
public final java.lang.StringtoString()
{@inheritDoc}

        StringBuffer sb = new StringBuffer(100);

        sb.append(identifierString());
        sb.append(' ");
        sb.append(position);

        sb.append(": ");
        sb.append(opcode.getName());

        boolean needComma = false;
        if (registers.size() != 0) {
            sb.append(registers.toHuman(" ", ", ", null));
            needComma = true;
        }

        String extra = argString();
        if (extra != null) {
            if (needComma) {
                sb.append(',");
            }
            sb.append(' ");
            sb.append(extra);
        }

        return sb.toString();
    
public com.android.dx.dex.code.DalvInsnwithMapper(com.android.dx.ssa.RegisterMapper mapper)
Returns an instance that is just like this one, except that the register list is mapped by using {@code mapper}.

param
mapper {@code non-null;} used to map registers
return
{@code non-null;} an appropriately-constructed instance

      return withRegisters(mapper.map(getRegisters()));
    
public abstract com.android.dx.dex.code.DalvInsnwithOpcode(Dop opcode)
Returns an instance that is just like this one, except that its opcode is replaced by the one given, and its address is reset.

param
opcode {@code non-null;} the new opcode
return
{@code non-null;} an appropriately-constructed instance

public abstract com.android.dx.dex.code.DalvInsnwithRegisterOffset(int delta)
Returns an instance that is just like this one, except that all register references have been offset by the given delta, and its address is reset.

param
delta the amount to offset register references by
return
{@code non-null;} an appropriately-constructed instance

public abstract com.android.dx.dex.code.DalvInsnwithRegisters(com.android.dx.rop.code.RegisterSpecList registers)
Returns an instance that is just like this one, except that the register list is replaced by the given one, and its address is reset.

param
registers {@code non-null;} new register list
return
{@code non-null;} an appropriately-constructed instance

public abstract voidwriteTo(com.android.dx.util.AnnotatedOutput out)
Writes this instance to the given output. This method should never annotate the output.

param
out {@code non-null;} where to write to