Add support for the odex only opcodes

git-svn-id: https://smali.googlecode.com/svn/trunk@432 55b6fa8a-2a1e-11de-a435-ffa8d773f76a

dexlib/src/main/java/org/jf/dexlib/Code/Format/Format.java

@@ -43,6 +43,7 @@ public enum Format {
     Format21t(Instruction21t.Factory, 4),
     Format22b(Instruction22b.Factory, 4),
     Format22c(Instruction22c.Factory, 4),
+    Format22cs(Instruction22cs.Factory, 4),
     Format22s(Instruction22s.Factory, 4),
     Format22t(Instruction22t.Factory, 4),
     Format22x(Instruction22x.Factory, 4),
@@ -53,7 +54,10 @@ public enum Format {
     Format31t(Instruction31t.Factory, 6),
     Format32x(Instruction32x.Factory, 6),
     Format35c(Instruction35c.Factory, 6),
+    Format35s(Instruction35s.Factory, 6),
+    Format35ms(Instruction35ms.Factory, 6),
     Format3rc(Instruction3rc.Factory, 6),
+    Format3rms(Instruction3rms.Factory, 6),
     Format51l(Instruction51l.Factory, 10),
     ArrayData(null, -1, true),
     PackedSwitchData(null, -1, true),

dexlib/src/main/java/org/jf/dexlib/Code/Format/Instruction22cs.java

@@ -0,0 +1,80 @@
+/*
+ * [The "BSD licence"]
+ * Copyright (c) 2009 Ben Gruver
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.jf.dexlib.Code.Format;
+
+import org.jf.dexlib.Code.Instruction;
+import org.jf.dexlib.Code.Opcode;
+import org.jf.dexlib.Util.Output;
+import org.jf.dexlib.Util.NumberUtils;
+import org.jf.dexlib.DexFile;
+
+public class Instruction22cs extends Instruction {
+    public static final Instruction.InstructionFactory Factory = new Factory();
+
+    public static void emit(Output out, Opcode opcode, byte regA, byte regB, int fieldOffset) {
+        if (regA >= 1 << 4 ||
+                regB >= 1 << 4) {
+            throw new RuntimeException("The register number must be less than v16");
+        }
+
+        if (fieldOffset >= 1 << 16) {
+            throw new RuntimeException("The field offset must be less than 65536");
+        }
+
+        out.writeByte(opcode.value);
+        out.writeByte((regB << 4) | regA);
+        out.writeShort(fieldOffset);
+    }
+
+    private Instruction22cs(Opcode opcode, byte[] buffer, int bufferIndex) {
+        super(opcode, buffer, bufferIndex);
+    }
+
+    public Format getFormat() {
+        return Format.Format22cs;
+    }
+
+    public byte getRegisterA() {
+        return NumberUtils.decodeLowUnsignedNibble(buffer[bufferIndex + 1]);
+    }
+
+    public byte getRegisterB() {
+        return NumberUtils.decodeHighUnsignedNibble(buffer[bufferIndex + 1]);
+    }
+
+    public int getFieldOffset() {
+        return NumberUtils.decodeUnsignedShort(buffer, bufferIndex + 2);
+    }
+
+    private static class Factory implements Instruction.InstructionFactory {
+        public Instruction makeInstruction(DexFile dexFile, Opcode opcode, byte[] buffer, int bufferIndex) {
+            return new Instruction22cs(opcode, buffer, bufferIndex);
+        }
+    }
+}

dexlib/src/main/java/org/jf/dexlib/Code/Format/Instruction35c.java

@@ -65,7 +65,7 @@ public class Instruction35c extends InstructionWithReference {
         checkItem(opcode, referencedItem, regCount);
     }
 
-    private Instruction35c(DexFile dexFile, Opcode opcode, byte[] buffer, int bufferIndex) {
+    protected Instruction35c(DexFile dexFile, Opcode opcode, byte[] buffer, int bufferIndex) {
         super(dexFile, opcode, buffer, bufferIndex);
 
         if (getRegCount() > 5) {

dexlib/src/main/java/org/jf/dexlib/Code/Format/Instruction35ms.java

@@ -0,0 +1,108 @@
+/*
+ * [The "BSD licence"]
+ * Copyright (c) 2009 Ben Gruver
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.jf.dexlib.Code.Format;
+
+import org.jf.dexlib.Code.Instruction;
+import org.jf.dexlib.Code.Opcode;
+import org.jf.dexlib.Util.Output;
+import org.jf.dexlib.Util.NumberUtils;
+import org.jf.dexlib.DexFile;
+
+
+public class Instruction35ms extends Instruction {
+    public static final Instruction.InstructionFactory Factory = new Factory();
+
+    public static void emit(Output out, Opcode opcode, int regCount, byte regD, byte regE, byte regF, byte regG,
+                          byte regA, int methodIndex) {
+        if (regCount > 5) {
+            throw new RuntimeException("regCount cannot be greater than 5");
+        }
+
+        if (regD >= 1 << 4 ||
+                regE >= 1 << 4 ||
+                regF >= 1 << 4 ||
+                regG >= 1 << 4 ||
+                regA >= 1 << 4) {
+            throw new RuntimeException("All register args must fit in 4 bits");
+        }
+
+        if (methodIndex >= 1 << 16) {
+            throw new RuntimeException("The method index must be less than 65536");
+        }
+
+        out.writeByte(opcode.value);
+        out.writeByte((regCount << 4) | regA);
+        out.writeShort(methodIndex);
+        out.writeByte((regE << 4) | regD);
+        out.writeByte((regG << 4) | regF);
+    }
+
+    private Instruction35ms(Opcode opcode, byte[] buffer, int bufferIndex) {
+        super(opcode, buffer, bufferIndex);
+    }
+
+    public Format getFormat() {
+        return Format.Format35ms;
+    }
+
+    public byte getRegisterA() {
+        return NumberUtils.decodeLowUnsignedNibble(buffer[bufferIndex + 1]);
+    }
+
+    public byte getRegCount() {
+        return NumberUtils.decodeHighUnsignedNibble(buffer[bufferIndex + 1]);
+    }
+
+    public byte getRegisterD() {
+        return NumberUtils.decodeLowUnsignedNibble(buffer[bufferIndex + 4]);
+    }
+
+    public byte getRegisterE() {
+        return NumberUtils.decodeHighUnsignedNibble(buffer[bufferIndex + 4]);
+    }
+
+    public byte getRegisterF() {
+        return NumberUtils.decodeLowUnsignedNibble(buffer[bufferIndex + 5]);
+    }
+
+    public byte getRegisterG() {
+        return NumberUtils.decodeHighUnsignedNibble(buffer[bufferIndex + 5]);
+    }
+
+    public int getMethodIndex() {
+        return NumberUtils.decodeUnsignedShort(buffer, bufferIndex + 2);
+    }
+
+    private static class Factory implements Instruction.InstructionFactory {
+        public Instruction makeInstruction(DexFile dexFile, Opcode opcode, byte[] buffer, int bufferIndex) {
+            return new Instruction35ms(opcode, buffer, bufferIndex);
+        }
+    }
+}
+

dexlib/src/main/java/org/jf/dexlib/Code/Format/Instruction35s.java

@@ -0,0 +1,58 @@
+/*
+ * [The "BSD licence"]
+ * Copyright (c) 2009 Ben Gruver
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.jf.dexlib.Code.Format;
+
+import org.jf.dexlib.Code.Instruction;
+import org.jf.dexlib.Code.Opcode;
+import org.jf.dexlib.Util.Output;
+import org.jf.dexlib.Item;
+import org.jf.dexlib.DexFile;
+
+public class Instruction35s extends Instruction35c {
+    public static final Instruction.InstructionFactory Factory = new Factory();
+
+    public static void emit(Output out, Opcode opcode, int regCount, byte regD, byte regE, byte regF, byte regG,
+                          byte regA, Item referencedItem) {
+        Instruction35c.emit(out, opcode, regCount, regD, regE, regF, regG, regA, referencedItem);
+    }
+
+    private Instruction35s(DexFile dexFile, Opcode opcode, byte[] buffer, int bufferIndex) {
+        super(dexFile, opcode, buffer, bufferIndex);
+    }
+
+    public Format getFormat() {
+        return Format.Format35s;
+    }
+
+    private static class Factory implements Instruction.InstructionFactory {
+        public Instruction makeInstruction(DexFile dexFile, Opcode opcode, byte[] buffer, int bufferIndex) {
+            return new Instruction35s(dexFile, opcode, buffer, bufferIndex);
+        }
+    }
+}

dexlib/src/main/java/org/jf/dexlib/Code/Format/Instruction3rms.java

@@ -0,0 +1,90 @@
+/*
+ * [The "BSD licence"]
+ * Copyright (c) 2009 Ben Gruver
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.jf.dexlib.Code.Format;
+
+import org.jf.dexlib.Code.Instruction;
+import org.jf.dexlib.Code.Opcode;
+import org.jf.dexlib.Util.Output;
+import org.jf.dexlib.Util.NumberUtils;
+import org.jf.dexlib.DexFile;
+
+public class Instruction3rms extends Instruction {
+ public static final Instruction.InstructionFactory Factory = new Factory();
+
+    public static void emit(Output out, Opcode opcode, short regCount, int startReg, int methodIndex) {
+        if (regCount >= 1 << 8) {
+            throw new RuntimeException("regCount must be less than 256");
+        }
+        if (regCount < 0) {
+            throw new RuntimeException("regCount cannot be negative");
+        }
+
+        if (startReg >= 1 << 16) {
+            throw new RuntimeException("The beginning register of the range must be less than 65536");
+        }
+        if (startReg < 0) {
+            throw new RuntimeException("The beginning register of the range cannot be negative");
+        }
+
+        if (methodIndex >= 1 << 16) {
+            throw new RuntimeException("The method index must be less than 65536");
+        }
+
+        out.writeByte(opcode.value);
+        out.writeByte(regCount);
+        out.writeShort(0);
+        out.writeShort(startReg);
+    }
+
+    private Instruction3rms(Opcode opcode, byte[] buffer, int bufferIndex) {
+        super(opcode, buffer, bufferIndex);
+    }
+
+    public Format getFormat() {
+        return Format.Format3rms;
+    }
+
+    public short getRegCount() {
+        return NumberUtils.decodeUnsignedByte(buffer[bufferIndex + 1]);
+    }
+
+    public int getStartRegister() {
+        return NumberUtils.decodeUnsignedShort(buffer, bufferIndex + 4);
+    }
+
+    public int getMethodIndex() {
+        return NumberUtils.decodeUnsignedShort(buffer, bufferIndex + 2);
+    }    
+
+    private static class Factory implements Instruction.InstructionFactory {
+        public Instruction makeInstruction(DexFile dexFile, Opcode opcode, byte[] buffer, int bufferIndex) {
+            return new Instruction3rms(opcode, buffer, bufferIndex);
+        }
+    }
+}

dexlib/src/main/java/org/jf/dexlib/Code/Opcode.java

@@ -251,7 +251,30 @@ public enum Opcode
     XOR_INT_LIT8((byte)0xdf, "xor-int/lit8", ReferenceType.none, Format.Format22b),
     SHL_INT_LIT8((byte)0xe0, "shl-int/lit8", ReferenceType.none, Format.Format22b),
     SHR_INT_LIT8((byte)0xe1, "shr-int/lit8", ReferenceType.none, Format.Format22b),
-    USHR_INT_LIT8((byte)0xe2, "ushr-int/lit8", ReferenceType.none, Format.Format22b);
+    USHR_INT_LIT8((byte)0xe2, "ushr-int/lit8", ReferenceType.none, Format.Format22b),
+
+
+    INVOKE_EXECUTE_INLINE((byte)0xee, "execute_inline", ReferenceType.none,  Format.Format35ms, true),
+
+    INVOKE_DIRECT_EMPTY((byte)0xf0, "invoke-direct-empty", ReferenceType.method,  Format.Format35s, true),
+
+    IGET_QUICK((byte)0xf2, "iget-quick", ReferenceType.none,  Format.Format22cs, true),
+    IGET_WIDE_QUICK((byte)0xf3, "iget-wide-quick", ReferenceType.none,  Format.Format22cs, true),
+    IGET_OBJECT_QUICK((byte)0xf4, "iget-object-quick", ReferenceType.none,  Format.Format22cs, true),
+
+    IPUT_QUICK((byte)0xf5, "iput-quick", ReferenceType.none,  Format.Format22cs, true),
+    IPUT_WIDE_QUICK((byte)0xf6, "iput-wide-quick", ReferenceType.none,  Format.Format22cs, true),
+    IPUT_OBJECT_QUICK((byte)0xf7, "iput-object-quick", ReferenceType.none,  Format.Format22cs, true),
+
+
+
+    INVOKE_VIRTUAL_QUICK((byte)0xf8, "invoke-virtual-quick", ReferenceType.none,  Format.Format35ms, true),
+    INVOKE_VIRTUAL_RANGE_QUICK((byte)0xf9, "invoke-virtual-range-quick", ReferenceType.none,  Format.Format3rms, true),
+
+    INVOKE_SUPERL_QUICK((byte)0xfa, "invoke-super-quick", ReferenceType.none,  Format.Format35ms, true),
+    INVOKE_SUPER_RANGE_QUICK((byte)0xfb, "invoke-super-range-quick", ReferenceType.none,  Format.Format3rms, true),
+
+    ;
 
 
 
@@ -280,11 +303,17 @@ public enum Opcode
     public final String name;
     public final ReferenceType referenceType;
     public final Format format;
-    
+    public final boolean odexOnly;
+
     Opcode(byte opcodeValue, String opcodeName, ReferenceType referenceType, Format format) {
+        this(opcodeValue, opcodeName, referenceType, format, false);
+    }
+    
+    Opcode(byte opcodeValue, String opcodeName, ReferenceType referenceType, Format format, boolean odexOnly) {
         this.value = opcodeValue;
         this.name = opcodeName;
         this.referenceType = referenceType;
         this.format = format;
+        this.odexOnly = odexOnly;
     }
 }