diff --git a/dexdump/DexDump.c b/dexdump/DexDump.c
index 5949303..556dbc2 100644
--- a/dexdump/DexDump.c
+++ b/dexdump/DexDump.c
@@ -1097,7 +1097,7 @@
             }
         }
 
-        dexDecodeInstruction(&gInstrInfo, insns, &decInsn);
+        dexDecodeInstruction(insns, &decInsn);
         dumpInstruction(pDexFile, pCode, insnIdx, insnWidth, &decInsn);
 
         insns += insnWidth;
@@ -1891,10 +1891,7 @@
     }
 
     /* initialize some VM tables */
-    if (dexCreateInstructionInfoTables(&gInstrInfo)) {
-        fprintf(stderr, "Failed to construct instruction tables\n");
-        return 1;
-    }
+    dexGetInstructionInfoTables(&gInstrInfo);
 
     if (wantUsage) {
         usage();
@@ -1906,7 +1903,5 @@
         result |= process(argv[optind++]);
     }
 
-    dexFreeInstructionInfoTables(&gInstrInfo);
-
     return (result != 0);
 }
diff --git a/libdex/InstrUtils.c b/libdex/InstrUtils.c
index ab15c81..936bd01 100644
--- a/libdex/InstrUtils.c
+++ b/libdex/InstrUtils.c
@@ -25,9 +25,6 @@
 #include "InstrUtils.h"
 #include <stdlib.h>
 
-#if 0
-/* coming soon! */
-
 /*
  * Table that maps each opcode to the full width of instructions that
  * use that opcode, in (16-bit) code units. Unimplemented opcodes as
@@ -459,1379 +456,23 @@
     kIndexUnknown,
     // END(libdex-index-types)
 };
-#endif
 
 /*
- * Generate a table that holds the width of all instructions.
- *
- * Unimplemented instructions have a width of zero.
- *
- * I'm doing it with a giant switch statement because it's easier to
- * maintain and update than a static table with 256 unadorned integers,
- * and if we're missing a case gcc emits a "warning: enumeration value not
- * handled" message.
- *
- * (To save space in the binary we could generate a static table with a
- * command-line utility.)
+ * Global InstructionInfoTables struct.
  */
-InstructionWidth* dexCreateInstrWidthTable(void)
-{
-#ifdef __ARM_ARCH_7A__
-    /* hack to work around mysterious problem on emulator */
-    LOGD("creating instr width table\n");
-#endif
-    InstructionWidth* instrWidth;
-    int i;
-
-    instrWidth = malloc(sizeof(InstructionWidth) * kNumDalvikInstructions);
-    if (instrWidth == NULL)
-        return NULL;
-
-    for (i = 0; i < kNumDalvikInstructions; i++) {
-        OpCode opc = (OpCode) i;
-        int width = 0;
-
-        switch (opc) {
-        case OP_NOP:    /* note data for e.g. switch-* encoded "inside" a NOP */
-        case OP_MOVE:
-        case OP_MOVE_WIDE:
-        case OP_MOVE_OBJECT:
-        case OP_MOVE_RESULT:
-        case OP_MOVE_RESULT_WIDE:
-        case OP_MOVE_RESULT_OBJECT:
-        case OP_MOVE_EXCEPTION:
-        case OP_RETURN_VOID:
-        case OP_RETURN:
-        case OP_RETURN_WIDE:
-        case OP_RETURN_OBJECT:
-        case OP_CONST_4:
-        case OP_MONITOR_ENTER:
-        case OP_MONITOR_EXIT:
-        case OP_ARRAY_LENGTH:
-        case OP_THROW:
-        case OP_GOTO:
-        case OP_NEG_INT:
-        case OP_NOT_INT:
-        case OP_NEG_LONG:
-        case OP_NOT_LONG:
-        case OP_NEG_FLOAT:
-        case OP_NEG_DOUBLE:
-        case OP_INT_TO_LONG:
-        case OP_INT_TO_FLOAT:
-        case OP_INT_TO_DOUBLE:
-        case OP_LONG_TO_INT:
-        case OP_LONG_TO_FLOAT:
-        case OP_LONG_TO_DOUBLE:
-        case OP_FLOAT_TO_INT:
-        case OP_FLOAT_TO_LONG:
-        case OP_FLOAT_TO_DOUBLE:
-        case OP_DOUBLE_TO_INT:
-        case OP_DOUBLE_TO_LONG:
-        case OP_DOUBLE_TO_FLOAT:
-        case OP_INT_TO_BYTE:
-        case OP_INT_TO_CHAR:
-        case OP_INT_TO_SHORT:
-        case OP_ADD_INT_2ADDR:
-        case OP_SUB_INT_2ADDR:
-        case OP_MUL_INT_2ADDR:
-        case OP_DIV_INT_2ADDR:
-        case OP_REM_INT_2ADDR:
-        case OP_AND_INT_2ADDR:
-        case OP_OR_INT_2ADDR:
-        case OP_XOR_INT_2ADDR:
-        case OP_SHL_INT_2ADDR:
-        case OP_SHR_INT_2ADDR:
-        case OP_USHR_INT_2ADDR:
-        case OP_ADD_LONG_2ADDR:
-        case OP_SUB_LONG_2ADDR:
-        case OP_MUL_LONG_2ADDR:
-        case OP_DIV_LONG_2ADDR:
-        case OP_REM_LONG_2ADDR:
-        case OP_AND_LONG_2ADDR:
-        case OP_OR_LONG_2ADDR:
-        case OP_XOR_LONG_2ADDR:
-        case OP_SHL_LONG_2ADDR:
-        case OP_SHR_LONG_2ADDR:
-        case OP_USHR_LONG_2ADDR:
-        case OP_ADD_FLOAT_2ADDR:
-        case OP_SUB_FLOAT_2ADDR:
-        case OP_MUL_FLOAT_2ADDR:
-        case OP_DIV_FLOAT_2ADDR:
-        case OP_REM_FLOAT_2ADDR:
-        case OP_ADD_DOUBLE_2ADDR:
-        case OP_SUB_DOUBLE_2ADDR:
-        case OP_MUL_DOUBLE_2ADDR:
-        case OP_DIV_DOUBLE_2ADDR:
-        case OP_REM_DOUBLE_2ADDR:
-            width = 1;
-            break;
-
-        case OP_MOVE_FROM16:
-        case OP_MOVE_WIDE_FROM16:
-        case OP_MOVE_OBJECT_FROM16:
-        case OP_CONST_16:
-        case OP_CONST_HIGH16:
-        case OP_CONST_WIDE_16:
-        case OP_CONST_WIDE_HIGH16:
-        case OP_CONST_STRING:
-        case OP_CONST_CLASS:
-        case OP_CHECK_CAST:
-        case OP_INSTANCE_OF:
-        case OP_NEW_INSTANCE:
-        case OP_NEW_ARRAY:
-        case OP_CMPL_FLOAT:
-        case OP_CMPG_FLOAT:
-        case OP_CMPL_DOUBLE:
-        case OP_CMPG_DOUBLE:
-        case OP_CMP_LONG:
-        case OP_GOTO_16:
-        case OP_IF_EQ:
-        case OP_IF_NE:
-        case OP_IF_LT:
-        case OP_IF_GE:
-        case OP_IF_GT:
-        case OP_IF_LE:
-        case OP_IF_EQZ:
-        case OP_IF_NEZ:
-        case OP_IF_LTZ:
-        case OP_IF_GEZ:
-        case OP_IF_GTZ:
-        case OP_IF_LEZ:
-        case OP_AGET:
-        case OP_AGET_WIDE:
-        case OP_AGET_OBJECT:
-        case OP_AGET_BOOLEAN:
-        case OP_AGET_BYTE:
-        case OP_AGET_CHAR:
-        case OP_AGET_SHORT:
-        case OP_APUT:
-        case OP_APUT_WIDE:
-        case OP_APUT_OBJECT:
-        case OP_APUT_BOOLEAN:
-        case OP_APUT_BYTE:
-        case OP_APUT_CHAR:
-        case OP_APUT_SHORT:
-        case OP_IGET:
-        case OP_IGET_WIDE:
-        case OP_IGET_OBJECT:
-        case OP_IGET_BOOLEAN:
-        case OP_IGET_BYTE:
-        case OP_IGET_CHAR:
-        case OP_IGET_SHORT:
-        case OP_IPUT:
-        case OP_IPUT_WIDE:
-        case OP_IPUT_OBJECT:
-        case OP_IPUT_BOOLEAN:
-        case OP_IPUT_BYTE:
-        case OP_IPUT_CHAR:
-        case OP_IPUT_SHORT:
-        case OP_SGET:
-        case OP_SGET_WIDE:
-        case OP_SGET_OBJECT:
-        case OP_SGET_BOOLEAN:
-        case OP_SGET_BYTE:
-        case OP_SGET_CHAR:
-        case OP_SGET_SHORT:
-        case OP_SPUT:
-        case OP_SPUT_WIDE:
-        case OP_SPUT_OBJECT:
-        case OP_SPUT_BOOLEAN:
-        case OP_SPUT_BYTE:
-        case OP_SPUT_CHAR:
-        case OP_SPUT_SHORT:
-        case OP_ADD_INT:
-        case OP_SUB_INT:
-        case OP_MUL_INT:
-        case OP_DIV_INT:
-        case OP_REM_INT:
-        case OP_AND_INT:
-        case OP_OR_INT:
-        case OP_XOR_INT:
-        case OP_SHL_INT:
-        case OP_SHR_INT:
-        case OP_USHR_INT:
-        case OP_ADD_LONG:
-        case OP_SUB_LONG:
-        case OP_MUL_LONG:
-        case OP_DIV_LONG:
-        case OP_REM_LONG:
-        case OP_AND_LONG:
-        case OP_OR_LONG:
-        case OP_XOR_LONG:
-        case OP_SHL_LONG:
-        case OP_SHR_LONG:
-        case OP_USHR_LONG:
-        case OP_ADD_FLOAT:
-        case OP_SUB_FLOAT:
-        case OP_MUL_FLOAT:
-        case OP_DIV_FLOAT:
-        case OP_REM_FLOAT:
-        case OP_ADD_DOUBLE:
-        case OP_SUB_DOUBLE:
-        case OP_MUL_DOUBLE:
-        case OP_DIV_DOUBLE:
-        case OP_REM_DOUBLE:
-        case OP_ADD_INT_LIT16:
-        case OP_RSUB_INT:
-        case OP_MUL_INT_LIT16:
-        case OP_DIV_INT_LIT16:
-        case OP_REM_INT_LIT16:
-        case OP_AND_INT_LIT16:
-        case OP_OR_INT_LIT16:
-        case OP_XOR_INT_LIT16:
-        case OP_ADD_INT_LIT8:
-        case OP_RSUB_INT_LIT8:
-        case OP_MUL_INT_LIT8:
-        case OP_DIV_INT_LIT8:
-        case OP_REM_INT_LIT8:
-        case OP_AND_INT_LIT8:
-        case OP_OR_INT_LIT8:
-        case OP_XOR_INT_LIT8:
-        case OP_SHL_INT_LIT8:
-        case OP_SHR_INT_LIT8:
-        case OP_USHR_INT_LIT8:
-            width = 2;
-            break;
-
-        case OP_MOVE_16:
-        case OP_MOVE_WIDE_16:
-        case OP_MOVE_OBJECT_16:
-        case OP_CONST:
-        case OP_CONST_WIDE_32:
-        case OP_CONST_STRING_JUMBO:
-        case OP_GOTO_32:
-        case OP_FILLED_NEW_ARRAY:
-        case OP_FILLED_NEW_ARRAY_RANGE:
-        case OP_FILL_ARRAY_DATA:
-        case OP_PACKED_SWITCH:
-        case OP_SPARSE_SWITCH:
-        case OP_INVOKE_VIRTUAL:
-        case OP_INVOKE_SUPER:
-        case OP_INVOKE_DIRECT:
-        case OP_INVOKE_STATIC:
-        case OP_INVOKE_INTERFACE:
-        case OP_INVOKE_VIRTUAL_RANGE:
-        case OP_INVOKE_SUPER_RANGE:
-        case OP_INVOKE_DIRECT_RANGE:
-        case OP_INVOKE_STATIC_RANGE:
-        case OP_INVOKE_INTERFACE_RANGE:
-            width = 3;
-            break;
-
-        case OP_CONST_WIDE:
-            width = 5;
-            break;
-
-        /*
-         * Optimized instructions.
-         */
-        case OP_RETURN_VOID_BARRIER:
-            width = 1;
-            break;
-        case OP_IGET_QUICK:
-        case OP_IGET_WIDE_QUICK:
-        case OP_IGET_OBJECT_QUICK:
-        case OP_IPUT_QUICK:
-        case OP_IPUT_WIDE_QUICK:
-        case OP_IPUT_OBJECT_QUICK:
-        case OP_IGET_VOLATILE:
-        case OP_IPUT_VOLATILE:
-        case OP_SGET_VOLATILE:
-        case OP_SPUT_VOLATILE:
-        case OP_IGET_OBJECT_VOLATILE:
-        case OP_IPUT_OBJECT_VOLATILE:
-        case OP_SGET_OBJECT_VOLATILE:
-        case OP_SPUT_OBJECT_VOLATILE:
-        case OP_IGET_WIDE_VOLATILE:
-        case OP_IPUT_WIDE_VOLATILE:
-        case OP_SGET_WIDE_VOLATILE:
-        case OP_SPUT_WIDE_VOLATILE:
-        case OP_THROW_VERIFICATION_ERROR:
-            width = 2;
-            break;
-        case OP_INVOKE_VIRTUAL_QUICK:
-        case OP_INVOKE_VIRTUAL_QUICK_RANGE:
-        case OP_INVOKE_SUPER_QUICK:
-        case OP_INVOKE_SUPER_QUICK_RANGE:
-        case OP_EXECUTE_INLINE:
-        case OP_EXECUTE_INLINE_RANGE:
-        case OP_INVOKE_DIRECT_EMPTY:
-            width = 3;
-            break;
-
-        /* these should never appear when scanning bytecode */
-        case OP_UNUSED_3E:
-        case OP_UNUSED_3F:
-        case OP_UNUSED_40:
-        case OP_UNUSED_41:
-        case OP_UNUSED_42:
-        case OP_UNUSED_43:
-        case OP_UNUSED_73:
-        case OP_UNUSED_79:
-        case OP_UNUSED_7A:
-        case OP_BREAKPOINT:
-        case OP_UNUSED_FF:
-            assert(width == 0);
-            break;
-
-        /*
-         * DO NOT add a "default" clause here.  Without it the compiler will
-         * complain if an instruction is missing (which is desirable).
-         */
-        }
-
-        instrWidth[opc] = width;
-    }
-
-    return instrWidth;
-}
+InstructionInfoTables gDexOpcodeInfo = {
+    gOpcodeFormatTable,
+    gOpcodeIndexTypeTable,
+    gOpcodeFlagsTable,
+    gOpcodeWidthTable
+};
 
 /*
- * Generate a table that holds instruction flags.
+ * Copy pointers to all of the instruction info tables into
+ * the given struct.
  */
-InstructionFlags* dexCreateInstrFlagsTable(void)
-{
-    InstructionFlags* instrFlags;
-    int i;
-
-    instrFlags = malloc(sizeof(InstructionFlags) * kNumDalvikInstructions);
-    if (instrFlags == NULL)
-        return NULL;
-
-    for (i = 0; i < kNumDalvikInstructions; i++) {
-        OpCode opc = (OpCode) i;
-        InstructionFlags flags = 0;
-
-        switch (opc) {
-        /* these don't affect the PC and can't cause an exception */
-        case OP_NOP:
-        case OP_MOVE:
-        case OP_MOVE_FROM16:
-        case OP_MOVE_16:
-        case OP_MOVE_WIDE:
-        case OP_MOVE_WIDE_FROM16:
-        case OP_MOVE_WIDE_16:
-        case OP_MOVE_OBJECT:
-        case OP_MOVE_OBJECT_FROM16:
-        case OP_MOVE_OBJECT_16:
-        case OP_MOVE_RESULT:
-        case OP_MOVE_RESULT_WIDE:
-        case OP_MOVE_RESULT_OBJECT:
-        case OP_MOVE_EXCEPTION:
-        case OP_CONST_4:
-        case OP_CONST_16:
-        case OP_CONST:
-        case OP_CONST_HIGH16:
-        case OP_CONST_WIDE_16:
-        case OP_CONST_WIDE_32:
-        case OP_CONST_WIDE:
-        case OP_CONST_WIDE_HIGH16:
-        case OP_FILL_ARRAY_DATA:
-        case OP_CMPL_FLOAT:
-        case OP_CMPG_FLOAT:
-        case OP_CMPL_DOUBLE:
-        case OP_CMPG_DOUBLE:
-        case OP_CMP_LONG:
-        case OP_NEG_INT:
-        case OP_NOT_INT:
-        case OP_NEG_LONG:
-        case OP_NOT_LONG:
-        case OP_NEG_FLOAT:
-        case OP_NEG_DOUBLE:
-        case OP_INT_TO_LONG:
-        case OP_INT_TO_FLOAT:
-        case OP_INT_TO_DOUBLE:
-        case OP_LONG_TO_INT:
-        case OP_LONG_TO_FLOAT:
-        case OP_LONG_TO_DOUBLE:
-        case OP_FLOAT_TO_INT:
-        case OP_FLOAT_TO_LONG:
-        case OP_FLOAT_TO_DOUBLE:
-        case OP_DOUBLE_TO_INT:
-        case OP_DOUBLE_TO_LONG:
-        case OP_DOUBLE_TO_FLOAT:
-        case OP_INT_TO_BYTE:
-        case OP_INT_TO_CHAR:
-        case OP_INT_TO_SHORT:
-        case OP_ADD_INT:
-        case OP_SUB_INT:
-        case OP_MUL_INT:
-        case OP_AND_INT:
-        case OP_OR_INT:
-        case OP_XOR_INT:
-        case OP_SHL_INT:
-        case OP_SHR_INT:
-        case OP_USHR_INT:
-        case OP_ADD_LONG:
-        case OP_SUB_LONG:
-        case OP_MUL_LONG:
-        case OP_AND_LONG:
-        case OP_OR_LONG:
-        case OP_XOR_LONG:
-        case OP_SHL_LONG:
-        case OP_SHR_LONG:
-        case OP_USHR_LONG:
-        case OP_ADD_FLOAT:
-        case OP_SUB_FLOAT:
-        case OP_MUL_FLOAT:
-        case OP_DIV_FLOAT:
-        case OP_REM_FLOAT:
-        case OP_ADD_DOUBLE:
-        case OP_SUB_DOUBLE:
-        case OP_MUL_DOUBLE:
-        case OP_DIV_DOUBLE:         // div by zero just returns NaN
-        case OP_REM_DOUBLE:
-        case OP_ADD_INT_2ADDR:
-        case OP_SUB_INT_2ADDR:
-        case OP_MUL_INT_2ADDR:
-        case OP_AND_INT_2ADDR:
-        case OP_OR_INT_2ADDR:
-        case OP_XOR_INT_2ADDR:
-        case OP_SHL_INT_2ADDR:
-        case OP_SHR_INT_2ADDR:
-        case OP_USHR_INT_2ADDR:
-        case OP_ADD_LONG_2ADDR:
-        case OP_SUB_LONG_2ADDR:
-        case OP_MUL_LONG_2ADDR:
-        case OP_AND_LONG_2ADDR:
-        case OP_OR_LONG_2ADDR:
-        case OP_XOR_LONG_2ADDR:
-        case OP_SHL_LONG_2ADDR:
-        case OP_SHR_LONG_2ADDR:
-        case OP_USHR_LONG_2ADDR:
-        case OP_ADD_FLOAT_2ADDR:
-        case OP_SUB_FLOAT_2ADDR:
-        case OP_MUL_FLOAT_2ADDR:
-        case OP_DIV_FLOAT_2ADDR:
-        case OP_REM_FLOAT_2ADDR:
-        case OP_ADD_DOUBLE_2ADDR:
-        case OP_SUB_DOUBLE_2ADDR:
-        case OP_MUL_DOUBLE_2ADDR:
-        case OP_DIV_DOUBLE_2ADDR:
-        case OP_REM_DOUBLE_2ADDR:
-        case OP_ADD_INT_LIT16:
-        case OP_RSUB_INT:
-        case OP_MUL_INT_LIT16:
-        case OP_AND_INT_LIT16:
-        case OP_OR_INT_LIT16:
-        case OP_XOR_INT_LIT16:
-        case OP_ADD_INT_LIT8:
-        case OP_RSUB_INT_LIT8:
-        case OP_MUL_INT_LIT8:
-        case OP_AND_INT_LIT8:
-        case OP_OR_INT_LIT8:
-        case OP_XOR_INT_LIT8:
-        case OP_SHL_INT_LIT8:
-        case OP_SHR_INT_LIT8:
-        case OP_USHR_INT_LIT8:
-            flags = kInstrCanContinue;
-            break;
-
-        /* these don't affect the PC, but can cause exceptions */
-        case OP_CONST_STRING:
-        case OP_CONST_STRING_JUMBO:
-        case OP_CONST_CLASS:
-        case OP_MONITOR_ENTER:
-        case OP_MONITOR_EXIT:
-        case OP_CHECK_CAST:
-        case OP_INSTANCE_OF:
-        case OP_ARRAY_LENGTH:
-        case OP_NEW_INSTANCE:
-        case OP_NEW_ARRAY:
-        case OP_FILLED_NEW_ARRAY:
-        case OP_FILLED_NEW_ARRAY_RANGE:
-        case OP_AGET:
-        case OP_AGET_BOOLEAN:
-        case OP_AGET_BYTE:
-        case OP_AGET_CHAR:
-        case OP_AGET_SHORT:
-        case OP_AGET_WIDE:
-        case OP_AGET_OBJECT:
-        case OP_APUT:
-        case OP_APUT_BOOLEAN:
-        case OP_APUT_BYTE:
-        case OP_APUT_CHAR:
-        case OP_APUT_SHORT:
-        case OP_APUT_WIDE:
-        case OP_APUT_OBJECT:
-        case OP_IGET:
-        case OP_IGET_BOOLEAN:
-        case OP_IGET_BYTE:
-        case OP_IGET_CHAR:
-        case OP_IGET_SHORT:
-        case OP_IGET_WIDE:
-        case OP_IGET_OBJECT:
-        case OP_IPUT:
-        case OP_IPUT_BOOLEAN:
-        case OP_IPUT_BYTE:
-        case OP_IPUT_CHAR:
-        case OP_IPUT_SHORT:
-        case OP_IPUT_WIDE:
-        case OP_IPUT_OBJECT:
-        case OP_SGET:
-        case OP_SGET_BOOLEAN:
-        case OP_SGET_BYTE:
-        case OP_SGET_CHAR:
-        case OP_SGET_SHORT:
-        case OP_SGET_WIDE:
-        case OP_SGET_OBJECT:
-        case OP_SPUT:
-        case OP_SPUT_BOOLEAN:
-        case OP_SPUT_BYTE:
-        case OP_SPUT_CHAR:
-        case OP_SPUT_SHORT:
-        case OP_SPUT_WIDE:
-        case OP_SPUT_OBJECT:
-        case OP_DIV_INT:
-        case OP_REM_INT:
-        case OP_DIV_LONG:
-        case OP_REM_LONG:
-        case OP_DIV_INT_2ADDR:
-        case OP_REM_INT_2ADDR:
-        case OP_DIV_LONG_2ADDR:
-        case OP_REM_LONG_2ADDR:
-        case OP_DIV_INT_LIT16:
-        case OP_REM_INT_LIT16:
-        case OP_DIV_INT_LIT8:
-        case OP_REM_INT_LIT8:
-            flags = kInstrCanContinue | kInstrCanThrow;
-            break;
-
-        case OP_INVOKE_VIRTUAL:
-        case OP_INVOKE_VIRTUAL_RANGE:
-        case OP_INVOKE_SUPER:
-        case OP_INVOKE_SUPER_RANGE:
-        case OP_INVOKE_DIRECT:
-        case OP_INVOKE_DIRECT_RANGE:
-        case OP_INVOKE_STATIC:
-        case OP_INVOKE_STATIC_RANGE:
-        case OP_INVOKE_INTERFACE:
-        case OP_INVOKE_INTERFACE_RANGE:
-            flags = kInstrCanContinue | kInstrCanThrow | kInstrInvoke;
-            break;
-
-        case OP_RETURN_VOID:
-        case OP_RETURN:
-        case OP_RETURN_WIDE:
-        case OP_RETURN_OBJECT:
-            flags = kInstrCanReturn;
-            break;
-
-        case OP_THROW:
-            flags = kInstrCanThrow;
-            break;
-
-        /* unconditional branches */
-        case OP_GOTO:
-        case OP_GOTO_16:
-        case OP_GOTO_32:
-            flags = kInstrCanBranch;
-            break;
-
-        /* conditional branches */
-        case OP_IF_EQ:
-        case OP_IF_NE:
-        case OP_IF_LT:
-        case OP_IF_GE:
-        case OP_IF_GT:
-        case OP_IF_LE:
-        case OP_IF_EQZ:
-        case OP_IF_NEZ:
-        case OP_IF_LTZ:
-        case OP_IF_GEZ:
-        case OP_IF_GTZ:
-        case OP_IF_LEZ:
-            flags = kInstrCanBranch | kInstrCanContinue;
-            break;
-
-        /* switch statements; if value not in switch, it continues */
-        case OP_PACKED_SWITCH:
-        case OP_SPARSE_SWITCH:
-            flags = kInstrCanSwitch | kInstrCanContinue;
-            break;
-
-        /* verifier/optimizer-generated instructions */
-        case OP_THROW_VERIFICATION_ERROR:
-            flags = kInstrCanThrow;
-            break;
-        case OP_EXECUTE_INLINE:
-        case OP_EXECUTE_INLINE_RANGE:
-            flags = kInstrCanContinue | kInstrCanThrow;
-            break;
-        case OP_IGET_QUICK:
-        case OP_IGET_WIDE_QUICK:
-        case OP_IGET_OBJECT_QUICK:
-        case OP_IPUT_QUICK:
-        case OP_IPUT_WIDE_QUICK:
-        case OP_IPUT_OBJECT_QUICK:
-        case OP_IGET_VOLATILE:
-        case OP_IPUT_VOLATILE:
-        case OP_SGET_VOLATILE:
-        case OP_SPUT_VOLATILE:
-        case OP_IGET_OBJECT_VOLATILE:
-        case OP_IPUT_OBJECT_VOLATILE:
-        case OP_SGET_OBJECT_VOLATILE:
-        case OP_SPUT_OBJECT_VOLATILE:
-        case OP_IGET_WIDE_VOLATILE:
-        case OP_IPUT_WIDE_VOLATILE:
-        case OP_SGET_WIDE_VOLATILE:
-        case OP_SPUT_WIDE_VOLATILE:
-            flags = kInstrCanContinue | kInstrCanThrow;
-            break;
-        case OP_INVOKE_VIRTUAL_QUICK:
-        case OP_INVOKE_VIRTUAL_QUICK_RANGE:
-        case OP_INVOKE_SUPER_QUICK:
-        case OP_INVOKE_SUPER_QUICK_RANGE:
-        case OP_INVOKE_DIRECT_EMPTY:
-            flags = kInstrCanContinue | kInstrCanThrow | kInstrInvoke;
-            break;
-        case OP_RETURN_VOID_BARRIER:
-            flags = kInstrCanReturn;
-            break;
-
-        /* these should never appear when scanning code */
-        case OP_UNUSED_3E:
-        case OP_UNUSED_3F:
-        case OP_UNUSED_40:
-        case OP_UNUSED_41:
-        case OP_UNUSED_42:
-        case OP_UNUSED_43:
-        case OP_UNUSED_73:
-        case OP_UNUSED_79:
-        case OP_UNUSED_7A:
-        case OP_BREAKPOINT:
-        case OP_UNUSED_FF:
-            break;
-
-        /*
-         * DO NOT add a "default" clause here.  Without it the compiler will
-         * complain if an instruction is missing (which is desirable).
-         */
-        }
-
-        instrFlags[opc] = flags;
-    }
-
-    return instrFlags;
-}
-
-/*
- * Allocate and populate a 256-element array with instruction formats.
- * Used in conjunction with dexDecodeInstruction.
- */
-InstructionFormat* dexCreateInstrFormatTable(void)
-{
-    InstructionFormat* instFmt;
-    int i;
-
-    instFmt = malloc(sizeof(InstructionFormat) * kNumDalvikInstructions);
-    if (instFmt == NULL)
-        return NULL;
-
-    for (i = 0; i < kNumDalvikInstructions; i++) {
-        OpCode opc = (OpCode) i;
-        InstructionFormat fmt = kFmt00x;
-
-        switch (opc) {
-        case OP_GOTO:
-            fmt = kFmt10t;
-            break;
-        case OP_NOP:
-        case OP_RETURN_VOID:
-            fmt = kFmt10x;
-            break;
-        case OP_CONST_4:
-            fmt = kFmt11n;
-            break;
-        case OP_CONST_HIGH16:
-        case OP_CONST_WIDE_HIGH16:
-            fmt = kFmt21h;
-            break;
-        case OP_MOVE_RESULT:
-        case OP_MOVE_RESULT_WIDE:
-        case OP_MOVE_RESULT_OBJECT:
-        case OP_MOVE_EXCEPTION:
-        case OP_RETURN:
-        case OP_RETURN_WIDE:
-        case OP_RETURN_OBJECT:
-        case OP_MONITOR_ENTER:
-        case OP_MONITOR_EXIT:
-        case OP_THROW:
-            fmt = kFmt11x;
-            break;
-        case OP_MOVE:
-        case OP_MOVE_WIDE:
-        case OP_MOVE_OBJECT:
-        case OP_ARRAY_LENGTH:
-        case OP_NEG_INT:
-        case OP_NOT_INT:
-        case OP_NEG_LONG:
-        case OP_NOT_LONG:
-        case OP_NEG_FLOAT:
-        case OP_NEG_DOUBLE:
-        case OP_INT_TO_LONG:
-        case OP_INT_TO_FLOAT:
-        case OP_INT_TO_DOUBLE:
-        case OP_LONG_TO_INT:
-        case OP_LONG_TO_FLOAT:
-        case OP_LONG_TO_DOUBLE:
-        case OP_FLOAT_TO_INT:
-        case OP_FLOAT_TO_LONG:
-        case OP_FLOAT_TO_DOUBLE:
-        case OP_DOUBLE_TO_INT:
-        case OP_DOUBLE_TO_LONG:
-        case OP_DOUBLE_TO_FLOAT:
-        case OP_INT_TO_BYTE:
-        case OP_INT_TO_CHAR:
-        case OP_INT_TO_SHORT:
-        case OP_ADD_INT_2ADDR:
-        case OP_SUB_INT_2ADDR:
-        case OP_MUL_INT_2ADDR:
-        case OP_DIV_INT_2ADDR:
-        case OP_REM_INT_2ADDR:
-        case OP_AND_INT_2ADDR:
-        case OP_OR_INT_2ADDR:
-        case OP_XOR_INT_2ADDR:
-        case OP_SHL_INT_2ADDR:
-        case OP_SHR_INT_2ADDR:
-        case OP_USHR_INT_2ADDR:
-        case OP_ADD_LONG_2ADDR:
-        case OP_SUB_LONG_2ADDR:
-        case OP_MUL_LONG_2ADDR:
-        case OP_DIV_LONG_2ADDR:
-        case OP_REM_LONG_2ADDR:
-        case OP_AND_LONG_2ADDR:
-        case OP_OR_LONG_2ADDR:
-        case OP_XOR_LONG_2ADDR:
-        case OP_SHL_LONG_2ADDR:
-        case OP_SHR_LONG_2ADDR:
-        case OP_USHR_LONG_2ADDR:
-        case OP_ADD_FLOAT_2ADDR:
-        case OP_SUB_FLOAT_2ADDR:
-        case OP_MUL_FLOAT_2ADDR:
-        case OP_DIV_FLOAT_2ADDR:
-        case OP_REM_FLOAT_2ADDR:
-        case OP_ADD_DOUBLE_2ADDR:
-        case OP_SUB_DOUBLE_2ADDR:
-        case OP_MUL_DOUBLE_2ADDR:
-        case OP_DIV_DOUBLE_2ADDR:
-        case OP_REM_DOUBLE_2ADDR:
-            fmt = kFmt12x;
-            break;
-        case OP_GOTO_16:
-            fmt = kFmt20t;
-            break;
-        case OP_GOTO_32:
-            fmt = kFmt30t;
-            break;
-        case OP_CONST_STRING:
-        case OP_CONST_CLASS:
-        case OP_CHECK_CAST:
-        case OP_NEW_INSTANCE:
-        case OP_SGET:
-        case OP_SGET_WIDE:
-        case OP_SGET_OBJECT:
-        case OP_SGET_BOOLEAN:
-        case OP_SGET_BYTE:
-        case OP_SGET_CHAR:
-        case OP_SGET_SHORT:
-        case OP_SPUT:
-        case OP_SPUT_WIDE:
-        case OP_SPUT_OBJECT:
-        case OP_SPUT_BOOLEAN:
-        case OP_SPUT_BYTE:
-        case OP_SPUT_CHAR:
-        case OP_SPUT_SHORT:
-            fmt = kFmt21c;
-            break;
-        case OP_CONST_16:
-        case OP_CONST_WIDE_16:
-            fmt = kFmt21s;
-            break;
-        case OP_IF_EQZ:
-        case OP_IF_NEZ:
-        case OP_IF_LTZ:
-        case OP_IF_GEZ:
-        case OP_IF_GTZ:
-        case OP_IF_LEZ:
-            fmt = kFmt21t;
-            break;
-        case OP_FILL_ARRAY_DATA:
-        case OP_PACKED_SWITCH:
-        case OP_SPARSE_SWITCH:
-            fmt = kFmt31t;
-            break;
-        case OP_ADD_INT_LIT8:
-        case OP_RSUB_INT_LIT8:
-        case OP_MUL_INT_LIT8:
-        case OP_DIV_INT_LIT8:
-        case OP_REM_INT_LIT8:
-        case OP_AND_INT_LIT8:
-        case OP_OR_INT_LIT8:
-        case OP_XOR_INT_LIT8:
-        case OP_SHL_INT_LIT8:
-        case OP_SHR_INT_LIT8:
-        case OP_USHR_INT_LIT8:
-            fmt = kFmt22b;
-            break;
-        case OP_INSTANCE_OF:
-        case OP_NEW_ARRAY:
-        case OP_IGET:
-        case OP_IGET_WIDE:
-        case OP_IGET_OBJECT:
-        case OP_IGET_BOOLEAN:
-        case OP_IGET_BYTE:
-        case OP_IGET_CHAR:
-        case OP_IGET_SHORT:
-        case OP_IPUT:
-        case OP_IPUT_WIDE:
-        case OP_IPUT_OBJECT:
-        case OP_IPUT_BOOLEAN:
-        case OP_IPUT_BYTE:
-        case OP_IPUT_CHAR:
-        case OP_IPUT_SHORT:
-            fmt = kFmt22c;
-            break;
-        case OP_ADD_INT_LIT16:
-        case OP_RSUB_INT:
-        case OP_MUL_INT_LIT16:
-        case OP_DIV_INT_LIT16:
-        case OP_REM_INT_LIT16:
-        case OP_AND_INT_LIT16:
-        case OP_OR_INT_LIT16:
-        case OP_XOR_INT_LIT16:
-            fmt = kFmt22s;
-            break;
-        case OP_IF_EQ:
-        case OP_IF_NE:
-        case OP_IF_LT:
-        case OP_IF_GE:
-        case OP_IF_GT:
-        case OP_IF_LE:
-            fmt = kFmt22t;
-            break;
-        case OP_MOVE_FROM16:
-        case OP_MOVE_WIDE_FROM16:
-        case OP_MOVE_OBJECT_FROM16:
-            fmt = kFmt22x;
-            break;
-        case OP_CMPL_FLOAT:
-        case OP_CMPG_FLOAT:
-        case OP_CMPL_DOUBLE:
-        case OP_CMPG_DOUBLE:
-        case OP_CMP_LONG:
-        case OP_AGET:
-        case OP_AGET_WIDE:
-        case OP_AGET_OBJECT:
-        case OP_AGET_BOOLEAN:
-        case OP_AGET_BYTE:
-        case OP_AGET_CHAR:
-        case OP_AGET_SHORT:
-        case OP_APUT:
-        case OP_APUT_WIDE:
-        case OP_APUT_OBJECT:
-        case OP_APUT_BOOLEAN:
-        case OP_APUT_BYTE:
-        case OP_APUT_CHAR:
-        case OP_APUT_SHORT:
-        case OP_ADD_INT:
-        case OP_SUB_INT:
-        case OP_MUL_INT:
-        case OP_DIV_INT:
-        case OP_REM_INT:
-        case OP_AND_INT:
-        case OP_OR_INT:
-        case OP_XOR_INT:
-        case OP_SHL_INT:
-        case OP_SHR_INT:
-        case OP_USHR_INT:
-        case OP_ADD_LONG:
-        case OP_SUB_LONG:
-        case OP_MUL_LONG:
-        case OP_DIV_LONG:
-        case OP_REM_LONG:
-        case OP_AND_LONG:
-        case OP_OR_LONG:
-        case OP_XOR_LONG:
-        case OP_SHL_LONG:
-        case OP_SHR_LONG:
-        case OP_USHR_LONG:
-        case OP_ADD_FLOAT:
-        case OP_SUB_FLOAT:
-        case OP_MUL_FLOAT:
-        case OP_DIV_FLOAT:
-        case OP_REM_FLOAT:
-        case OP_ADD_DOUBLE:
-        case OP_SUB_DOUBLE:
-        case OP_MUL_DOUBLE:
-        case OP_DIV_DOUBLE:
-        case OP_REM_DOUBLE:
-            fmt = kFmt23x;
-            break;
-        case OP_CONST:
-        case OP_CONST_WIDE_32:
-            fmt = kFmt31i;
-            break;
-        case OP_CONST_STRING_JUMBO:
-            fmt = kFmt31c;
-            break;
-        case OP_MOVE_16:
-        case OP_MOVE_WIDE_16:
-        case OP_MOVE_OBJECT_16:
-            fmt = kFmt32x;
-            break;
-        case OP_FILLED_NEW_ARRAY:
-        case OP_INVOKE_VIRTUAL:
-        case OP_INVOKE_SUPER:
-        case OP_INVOKE_DIRECT:
-        case OP_INVOKE_STATIC:
-        case OP_INVOKE_INTERFACE:
-            fmt = kFmt35c;
-            break;
-        case OP_FILLED_NEW_ARRAY_RANGE:
-        case OP_INVOKE_VIRTUAL_RANGE:
-        case OP_INVOKE_SUPER_RANGE:
-        case OP_INVOKE_DIRECT_RANGE:
-        case OP_INVOKE_STATIC_RANGE:
-        case OP_INVOKE_INTERFACE_RANGE:
-            fmt = kFmt3rc;
-            break;
-        case OP_CONST_WIDE:
-            fmt = kFmt51l;
-            break;
-
-        /*
-         * Optimized instructions.
-         */
-        case OP_THROW_VERIFICATION_ERROR:
-            fmt = kFmt20bc;
-            break;
-        case OP_IGET_WIDE_VOLATILE:
-        case OP_IPUT_WIDE_VOLATILE:
-        case OP_IGET_VOLATILE:
-        case OP_IPUT_VOLATILE:
-        case OP_IGET_OBJECT_VOLATILE:
-        case OP_IPUT_OBJECT_VOLATILE:
-            fmt = kFmt22c;
-            break;
-        case OP_SGET_OBJECT_VOLATILE:
-        case OP_SPUT_OBJECT_VOLATILE:
-        case OP_SGET_VOLATILE:
-        case OP_SPUT_VOLATILE:
-        case OP_SGET_WIDE_VOLATILE:
-        case OP_SPUT_WIDE_VOLATILE:
-            fmt = kFmt21c;
-            break;
-        case OP_IGET_QUICK:
-        case OP_IGET_WIDE_QUICK:
-        case OP_IGET_OBJECT_QUICK:
-        case OP_IPUT_QUICK:
-        case OP_IPUT_WIDE_QUICK:
-        case OP_IPUT_OBJECT_QUICK:
-            fmt = kFmt22cs;
-            break;
-        case OP_INVOKE_VIRTUAL_QUICK:
-        case OP_INVOKE_SUPER_QUICK:
-            fmt = kFmt35ms;
-            break;
-        case OP_INVOKE_VIRTUAL_QUICK_RANGE:
-        case OP_INVOKE_SUPER_QUICK_RANGE:
-            fmt = kFmt3rms;
-            break;
-        case OP_EXECUTE_INLINE:
-            fmt = kFmt35mi;
-            break;
-        case OP_EXECUTE_INLINE_RANGE:
-            fmt = kFmt3rmi;
-            break;
-        case OP_INVOKE_DIRECT_EMPTY:
-            fmt = kFmt35c;
-            break;
-        case OP_RETURN_VOID_BARRIER:
-            fmt = kFmt10x;
-            break;
-
-        /* these should never appear when scanning code */
-        case OP_UNUSED_3E:
-        case OP_UNUSED_3F:
-        case OP_UNUSED_40:
-        case OP_UNUSED_41:
-        case OP_UNUSED_42:
-        case OP_UNUSED_43:
-        case OP_UNUSED_73:
-        case OP_UNUSED_79:
-        case OP_UNUSED_7A:
-        case OP_BREAKPOINT:
-        case OP_UNUSED_FF:
-            fmt = kFmt00x;
-            break;
-
-        /*
-         * DO NOT add a "default" clause here.  Without it the compiler will
-         * complain if an instruction is missing (which is desirable).
-         */
-        }
-
-        instFmt[opc] = fmt;
-    }
-
-    return instFmt;
-}
-
-/*
- * Allocate and populate an array with index types for all instructions.
- * Used in conjunction with dexDecodeInstruction.
- */
-InstructionIndexType* dexCreateInstrIndexTypeTable(void)
-{
-    InstructionIndexType* indexTypes;
-    int i;
-
-    indexTypes = malloc(sizeof(InstructionIndexType) * kNumDalvikInstructions);
-    if (indexTypes == NULL)
-        return NULL;
-
-    for (i = 0; i < kNumDalvikInstructions; i++) {
-        OpCode opc = (OpCode) i;
-        InstructionIndexType indexType = kIndexUnknown;
-
-        switch (opc) {
-        case OP_GOTO:
-        case OP_NOP:
-        case OP_RETURN_VOID:
-        case OP_CONST_4:
-        case OP_CONST_HIGH16:
-        case OP_CONST_WIDE_HIGH16:
-        case OP_MOVE_RESULT:
-        case OP_MOVE_RESULT_WIDE:
-        case OP_MOVE_RESULT_OBJECT:
-        case OP_MOVE_EXCEPTION:
-        case OP_RETURN:
-        case OP_RETURN_WIDE:
-        case OP_RETURN_OBJECT:
-        case OP_MONITOR_ENTER:
-        case OP_MONITOR_EXIT:
-        case OP_THROW:
-        case OP_MOVE:
-        case OP_MOVE_WIDE:
-        case OP_MOVE_OBJECT:
-        case OP_ARRAY_LENGTH:
-        case OP_NEG_INT:
-        case OP_NOT_INT:
-        case OP_NEG_LONG:
-        case OP_NOT_LONG:
-        case OP_NEG_FLOAT:
-        case OP_NEG_DOUBLE:
-        case OP_INT_TO_LONG:
-        case OP_INT_TO_FLOAT:
-        case OP_INT_TO_DOUBLE:
-        case OP_LONG_TO_INT:
-        case OP_LONG_TO_FLOAT:
-        case OP_LONG_TO_DOUBLE:
-        case OP_FLOAT_TO_INT:
-        case OP_FLOAT_TO_LONG:
-        case OP_FLOAT_TO_DOUBLE:
-        case OP_DOUBLE_TO_INT:
-        case OP_DOUBLE_TO_LONG:
-        case OP_DOUBLE_TO_FLOAT:
-        case OP_INT_TO_BYTE:
-        case OP_INT_TO_CHAR:
-        case OP_INT_TO_SHORT:
-        case OP_ADD_INT_2ADDR:
-        case OP_SUB_INT_2ADDR:
-        case OP_MUL_INT_2ADDR:
-        case OP_DIV_INT_2ADDR:
-        case OP_REM_INT_2ADDR:
-        case OP_AND_INT_2ADDR:
-        case OP_OR_INT_2ADDR:
-        case OP_XOR_INT_2ADDR:
-        case OP_SHL_INT_2ADDR:
-        case OP_SHR_INT_2ADDR:
-        case OP_USHR_INT_2ADDR:
-        case OP_ADD_LONG_2ADDR:
-        case OP_SUB_LONG_2ADDR:
-        case OP_MUL_LONG_2ADDR:
-        case OP_DIV_LONG_2ADDR:
-        case OP_REM_LONG_2ADDR:
-        case OP_AND_LONG_2ADDR:
-        case OP_OR_LONG_2ADDR:
-        case OP_XOR_LONG_2ADDR:
-        case OP_SHL_LONG_2ADDR:
-        case OP_SHR_LONG_2ADDR:
-        case OP_USHR_LONG_2ADDR:
-        case OP_ADD_FLOAT_2ADDR:
-        case OP_SUB_FLOAT_2ADDR:
-        case OP_MUL_FLOAT_2ADDR:
-        case OP_DIV_FLOAT_2ADDR:
-        case OP_REM_FLOAT_2ADDR:
-        case OP_ADD_DOUBLE_2ADDR:
-        case OP_SUB_DOUBLE_2ADDR:
-        case OP_MUL_DOUBLE_2ADDR:
-        case OP_DIV_DOUBLE_2ADDR:
-        case OP_REM_DOUBLE_2ADDR:
-        case OP_GOTO_16:
-        case OP_GOTO_32:
-        case OP_CONST_16:
-        case OP_CONST_WIDE_16:
-        case OP_IF_EQZ:
-        case OP_IF_NEZ:
-        case OP_IF_LTZ:
-        case OP_IF_GEZ:
-        case OP_IF_GTZ:
-        case OP_IF_LEZ:
-        case OP_FILL_ARRAY_DATA:
-        case OP_PACKED_SWITCH:
-        case OP_SPARSE_SWITCH:
-        case OP_ADD_INT_LIT8:
-        case OP_RSUB_INT_LIT8:
-        case OP_MUL_INT_LIT8:
-        case OP_DIV_INT_LIT8:
-        case OP_REM_INT_LIT8:
-        case OP_AND_INT_LIT8:
-        case OP_OR_INT_LIT8:
-        case OP_XOR_INT_LIT8:
-        case OP_SHL_INT_LIT8:
-        case OP_SHR_INT_LIT8:
-        case OP_USHR_INT_LIT8:
-        case OP_ADD_INT_LIT16:
-        case OP_RSUB_INT:
-        case OP_MUL_INT_LIT16:
-        case OP_DIV_INT_LIT16:
-        case OP_REM_INT_LIT16:
-        case OP_AND_INT_LIT16:
-        case OP_OR_INT_LIT16:
-        case OP_XOR_INT_LIT16:
-        case OP_IF_EQ:
-        case OP_IF_NE:
-        case OP_IF_LT:
-        case OP_IF_GE:
-        case OP_IF_GT:
-        case OP_IF_LE:
-        case OP_MOVE_FROM16:
-        case OP_MOVE_WIDE_FROM16:
-        case OP_MOVE_OBJECT_FROM16:
-        case OP_CMPL_FLOAT:
-        case OP_CMPG_FLOAT:
-        case OP_CMPL_DOUBLE:
-        case OP_CMPG_DOUBLE:
-        case OP_CMP_LONG:
-        case OP_AGET:
-        case OP_AGET_WIDE:
-        case OP_AGET_OBJECT:
-        case OP_AGET_BOOLEAN:
-        case OP_AGET_BYTE:
-        case OP_AGET_CHAR:
-        case OP_AGET_SHORT:
-        case OP_APUT:
-        case OP_APUT_WIDE:
-        case OP_APUT_OBJECT:
-        case OP_APUT_BOOLEAN:
-        case OP_APUT_BYTE:
-        case OP_APUT_CHAR:
-        case OP_APUT_SHORT:
-        case OP_ADD_INT:
-        case OP_SUB_INT:
-        case OP_MUL_INT:
-        case OP_DIV_INT:
-        case OP_REM_INT:
-        case OP_AND_INT:
-        case OP_OR_INT:
-        case OP_XOR_INT:
-        case OP_SHL_INT:
-        case OP_SHR_INT:
-        case OP_USHR_INT:
-        case OP_ADD_LONG:
-        case OP_SUB_LONG:
-        case OP_MUL_LONG:
-        case OP_DIV_LONG:
-        case OP_REM_LONG:
-        case OP_AND_LONG:
-        case OP_OR_LONG:
-        case OP_XOR_LONG:
-        case OP_SHL_LONG:
-        case OP_SHR_LONG:
-        case OP_USHR_LONG:
-        case OP_ADD_FLOAT:
-        case OP_SUB_FLOAT:
-        case OP_MUL_FLOAT:
-        case OP_DIV_FLOAT:
-        case OP_REM_FLOAT:
-        case OP_ADD_DOUBLE:
-        case OP_SUB_DOUBLE:
-        case OP_MUL_DOUBLE:
-        case OP_DIV_DOUBLE:
-        case OP_REM_DOUBLE:
-        case OP_CONST:
-        case OP_CONST_WIDE_32:
-        case OP_MOVE_16:
-        case OP_MOVE_WIDE_16:
-        case OP_MOVE_OBJECT_16:
-        case OP_CONST_WIDE:
-            indexType = kIndexNone;
-            break;
-        case OP_CONST_STRING:
-        case OP_CONST_STRING_JUMBO:
-            indexType = kIndexStringRef;
-            break;
-        case OP_CONST_CLASS:
-        case OP_CHECK_CAST:
-        case OP_NEW_INSTANCE:
-        case OP_INSTANCE_OF:
-        case OP_NEW_ARRAY:
-        case OP_FILLED_NEW_ARRAY:
-        case OP_FILLED_NEW_ARRAY_RANGE:
-            indexType = kIndexTypeRef;
-            break;
-        case OP_SGET:
-        case OP_SGET_WIDE:
-        case OP_SGET_OBJECT:
-        case OP_SGET_BOOLEAN:
-        case OP_SGET_BYTE:
-        case OP_SGET_CHAR:
-        case OP_SGET_SHORT:
-        case OP_SPUT:
-        case OP_SPUT_WIDE:
-        case OP_SPUT_OBJECT:
-        case OP_SPUT_BOOLEAN:
-        case OP_SPUT_BYTE:
-        case OP_SPUT_CHAR:
-        case OP_SPUT_SHORT:
-        case OP_IGET:
-        case OP_IGET_WIDE:
-        case OP_IGET_OBJECT:
-        case OP_IGET_BOOLEAN:
-        case OP_IGET_BYTE:
-        case OP_IGET_CHAR:
-        case OP_IGET_SHORT:
-        case OP_IPUT:
-        case OP_IPUT_WIDE:
-        case OP_IPUT_OBJECT:
-        case OP_IPUT_BOOLEAN:
-        case OP_IPUT_BYTE:
-        case OP_IPUT_CHAR:
-        case OP_IPUT_SHORT:
-            indexType = kIndexFieldRef;
-            break;
-        case OP_INVOKE_VIRTUAL:
-        case OP_INVOKE_SUPER:
-        case OP_INVOKE_DIRECT:
-        case OP_INVOKE_STATIC:
-        case OP_INVOKE_INTERFACE:
-        case OP_INVOKE_VIRTUAL_RANGE:
-        case OP_INVOKE_SUPER_RANGE:
-        case OP_INVOKE_DIRECT_RANGE:
-        case OP_INVOKE_STATIC_RANGE:
-        case OP_INVOKE_INTERFACE_RANGE:
-            indexType = kIndexMethodRef;
-            break;
-
-        /*
-         * Optimized instructions.
-         */
-        case OP_THROW_VERIFICATION_ERROR:
-            indexType = kIndexVaries;
-            break;
-        case OP_IGET_WIDE_VOLATILE:
-        case OP_IPUT_WIDE_VOLATILE:
-        case OP_IGET_VOLATILE:
-        case OP_IPUT_VOLATILE:
-        case OP_IGET_OBJECT_VOLATILE:
-        case OP_IPUT_OBJECT_VOLATILE:
-        case OP_SGET_OBJECT_VOLATILE:
-        case OP_SPUT_OBJECT_VOLATILE:
-        case OP_SGET_VOLATILE:
-        case OP_SPUT_VOLATILE:
-        case OP_SGET_WIDE_VOLATILE:
-        case OP_SPUT_WIDE_VOLATILE:
-            indexType = kIndexFieldRef;
-            break;
-        case OP_IGET_QUICK:
-        case OP_IGET_WIDE_QUICK:
-        case OP_IGET_OBJECT_QUICK:
-        case OP_IPUT_QUICK:
-        case OP_IPUT_WIDE_QUICK:
-        case OP_IPUT_OBJECT_QUICK:
-            indexType = kIndexFieldOffset;
-            break;
-        case OP_INVOKE_VIRTUAL_QUICK:
-        case OP_INVOKE_SUPER_QUICK:
-        case OP_INVOKE_VIRTUAL_QUICK_RANGE:
-        case OP_INVOKE_SUPER_QUICK_RANGE:
-            indexType = kIndexVtableOffset;
-            break;
-        case OP_EXECUTE_INLINE:
-        case OP_EXECUTE_INLINE_RANGE:
-            indexType = kIndexInlineMethod;
-            break;
-        case OP_INVOKE_DIRECT_EMPTY:
-            indexType = kIndexMethodRef;
-            break;
-        case OP_RETURN_VOID_BARRIER:
-            indexType = kIndexNone;
-            break;
-
-        /* these should never appear when scanning code */
-        case OP_UNUSED_3E:
-        case OP_UNUSED_3F:
-        case OP_UNUSED_40:
-        case OP_UNUSED_41:
-        case OP_UNUSED_42:
-        case OP_UNUSED_43:
-        case OP_UNUSED_73:
-        case OP_UNUSED_79:
-        case OP_UNUSED_7A:
-        case OP_BREAKPOINT:
-        case OP_UNUSED_FF:
-            indexType = kIndexUnknown;
-            break;
-
-        /*
-         * DO NOT add a "default" clause here.  Without it the compiler will
-         * complain if an instruction is missing (which is desirable).
-         */
-        }
-
-        indexTypes[opc] = indexType;
-    }
-
-    return indexTypes;
-}
-
-/*
- * Construct all of the instruction info tables, storing references to
- * them into the given struct. This returns 0 on success or non-zero on
- * failure. If this fails, then no net allocation will have occurred.
- */
-int dexCreateInstructionInfoTables(InstructionInfoTables* info) {
-    info->formats = NULL;
-    info->indexTypes = NULL;
-    info->flags = NULL;
-    info->widths = NULL;
-
-    info->formats = dexCreateInstrFormatTable();
-    info->indexTypes = dexCreateInstrIndexTypeTable();
-    info->flags = dexCreateInstrFlagsTable();
-    info->widths = dexCreateInstrWidthTable();
-
-    if ((info->formats == NULL)
-            || (info->indexTypes == NULL)
-            || (info->flags == NULL)
-            || (info->widths == NULL)) {
-        dexFreeInstructionInfoTables(info);
-        return 1;
-    }
-
-    return 0;
-}
-
-/*
- * Free up the tables referred to by the given instruction info struct.
- */
-void dexFreeInstructionInfoTables(InstructionInfoTables* info) {
-    free(info->formats);
-    free(info->indexTypes);
-    free(info->flags);
-    free(info->widths);
+void dexGetInstructionInfoTables(InstructionInfoTables* info) {
+    *info = gDexOpcodeInfo;
 }
 
 /*
@@ -1855,15 +496,14 @@
  * Fills out the pieces of "pDec" that are affected by the current
  * instruction.  Does not touch anything else.
  */
-void dexDecodeInstruction(const InstructionInfoTables* info, const u2* insns,
-    DecodedInstruction* pDec)
+void dexDecodeInstruction(const u2* insns, DecodedInstruction* pDec)
 {
     u2 inst = *insns;
     OpCode opCode = (OpCode) INST_INST(inst);
-    InstructionFormat format = dexGetInstrFormat(info->formats, opCode);
+    InstructionFormat format = dexGetInstrFormat(gOpcodeFormatTable, opCode);
 
     pDec->opCode = opCode;
-    pDec->indexType = dexGetInstrIndexType(info->indexTypes, opCode);
+    pDec->indexType = dexGetInstrIndexType(gOpcodeIndexTypeTable, opCode);
 
     switch (format) {
     case kFmt10x:       // op
@@ -2062,8 +702,7 @@
  * works for special OP_NOP entries, including switch statement data tables
  * and array data.
  */
-size_t dexGetInstrOrTableWidth(const InstructionWidth* widths,
-    const u2* insns)
+size_t dexGetInstrOrTableWidth(const u2* insns)
 {
     size_t width;
 
@@ -2076,7 +715,7 @@
         u4 len = insns[2] | (((u4)insns[3]) << 16);
         width = 4 + (elemWidth * len + 1) / 2;
     } else {
-        width = dexGetInstrWidth(widths, INST_INST(insns[0]));
+        width = dexGetInstrWidth(gOpcodeWidthTable, INST_INST(insns[0]));
     }
     return width;
 }
diff --git a/libdex/InstrUtils.h b/libdex/InstrUtils.h
index 44e5af2..b4678ff 100644
--- a/libdex/InstrUtils.h
+++ b/libdex/InstrUtils.h
@@ -138,10 +138,9 @@
 } InstructionInfoTables;
 
 /*
- * Allocate and populate a 256-element array with instruction widths.  A
- * width of zero means the entry does not exist.
+ * Global InstructionInfoTables struct.
  */
-InstructionWidth* dexCreateInstrWidthTable(void);
+extern InstructionInfoTables gDexOpcodeInfo;
 
 /*
  * Return the width of the specified instruction, or 0 if not defined.
@@ -158,13 +157,7 @@
  * works for special OP_NOP entries, including switch statement data tables
  * and array data.
  */
-size_t dexGetInstrOrTableWidth(const InstructionWidth* widths,
-    const u2* insns);
-
-/*
- * Allocate and populate a 256-element array with instruction flags.
- */
-InstructionFlags* dexCreateInstrFlagsTable(void);
+size_t dexGetInstrOrTableWidth(const u2* insns);
 
 /*
  * Returns the flags for the specified opcode.
@@ -184,11 +177,6 @@
 }
 
 /*
- * Allocate and populate a 256-element array with instruction formats.
- */
-InstructionFormat* dexCreateInstrFormatTable(void);
-
-/*
  * Return the instruction format for the specified opcode.
  */
 DEX_INLINE InstructionFormat dexGetInstrFormat(const InstructionFormat* fmts,
@@ -199,12 +187,6 @@
 }
 
 /*
- * Allocate and populate an array with index types for all instructions.
- * Used in conjunction with dexDecodeInstruction.
- */
-InstructionIndexType* dexCreateInstrIndexTypeTable(void);
-
-/*
  * Return the instruction index type for the specified opcode.
  */
 DEX_INLINE InstructionIndexType dexGetInstrIndexType(
@@ -215,21 +197,14 @@
 }
 
 /*
- * Construct all of the instruction info tables, storing references to
- * them into the given struct. This returns 0 on success or non-zero on
- * failure. If this fails, then no net allocation will have occurred.
+ * Copy pointers to all of the instruction info tables into
+ * the given struct.
  */
-int dexCreateInstructionInfoTables(InstructionInfoTables* info);
-
-/*
- * Free up the tables referred to by the given instruction info struct.
- */
-void dexFreeInstructionInfoTables(InstructionInfoTables* info);
+void dexGetInstructionInfoTables(InstructionInfoTables* info);
 
 /*
  * Decode the instruction pointed to by "insns".
  */
-void dexDecodeInstruction(const InstructionInfoTables* info, const u2* insns,
-    DecodedInstruction* pDec);
+void dexDecodeInstruction(const u2* insns, DecodedInstruction* pDec);
 
 #endif /*_LIBDEX_INSTRUTILS*/
diff --git a/libdex/OpCode.h b/libdex/OpCode.h
index 32d3b3e..4c5ae52 100644
--- a/libdex/OpCode.h
+++ b/libdex/OpCode.h
@@ -41,8 +41,8 @@
  *    immediately below in this file.
  *
  * Opcode definitions and attributes:
- *  - update the instruction info table generators and (if you changed an
- *    instruction format) instruction decoder in InstrUtils.c
+ *  - update the instruction decoder in InstrUtils.c if you added a new
+ *    instruction format.
  *  - update the instruction format list in InstrUtils.h, if necessary
  *  - update the parallel definitions in the class dalvik.bytecode.Opcodes
  *
diff --git a/vm/analysis/CodeVerify.c b/vm/analysis/CodeVerify.c
index 2069848..e9ae842 100644
--- a/vm/analysis/CodeVerify.c
+++ b/vm/analysis/CodeVerify.c
@@ -3557,7 +3557,7 @@
 #ifndef NDEBUG
     memset(&decInsn, 0x81, sizeof(decInsn));
 #endif
-    dexDecodeInstruction(&gDvm.instrInfo, insns, &decInsn);
+    dexDecodeInstruction(insns, &decInsn);
 
     int nextFlags = dexGetInstrFlags(gDvm.instrInfo.flags, decInsn.opCode);
 
diff --git a/vm/analysis/DexVerify.c b/vm/analysis/DexVerify.c
index b35c4ae..654bd01 100644
--- a/vm/analysis/DexVerify.c
+++ b/vm/analysis/DexVerify.c
@@ -33,11 +33,7 @@
  */
 bool dvmVerificationStartup(void)
 {
-    if (dexCreateInstructionInfoTables(&gDvm.instrInfo)) {
-        LOGE("Unable to create instruction tables\n");
-        return false;
-    }
-
+    dexGetInstructionInfoTables(&gDvm.instrInfo);
     return true;
 }
 
@@ -46,7 +42,7 @@
  */
 void dvmVerificationShutdown(void)
 {
-    dexFreeInstructionInfoTables(&gDvm.instrInfo);
+    /* No need to do anything here. */
 }
 
 /*
@@ -112,7 +108,7 @@
 
 
     for (i = 0; i < (int) insnCount; /**/) {
-        size_t width = dexGetInstrOrTableWidth(gDvm.instrInfo.widths, insns);
+        size_t width = dexGetInstrOrTableWidth(insns);
         if (width == 0) {
             LOG_VFY_METH(meth,
                 "VFY: invalid post-opt instruction (0x%04x)\n", *insns);
@@ -817,7 +813,6 @@
     const Method* meth = vdata->method;
     const DvmDex* pDvmDex = meth->clazz->pDvmDex;
     InsnFlags* insnFlags = vdata->insnFlags;
-    const InstructionInfoTables* infoTables = &gDvm.instrInfo;
     const InstructionFlags* flagTable = gDvm.instrInfo.flags;
     const u2* insns = meth->insns;
     unsigned int codeOffset;
@@ -833,7 +828,7 @@
         DecodedInstruction decInsn;
         bool okay = true;
 
-        dexDecodeInstruction(infoTables, meth->insns + codeOffset, &decInsn);
+        dexDecodeInstruction(meth->insns + codeOffset, &decInsn);
 
         /*
          * Check register, type, class, field, method, and string indices
diff --git a/vm/analysis/Optimize.c b/vm/analysis/Optimize.c
index 6bc221e..5204096 100644
--- a/vm/analysis/Optimize.c
+++ b/vm/analysis/Optimize.c
@@ -299,7 +299,7 @@
             }
         }
 
-        width = dexGetInstrOrTableWidth(gDvm.instrInfo.widths, insns);
+        width = dexGetInstrOrTableWidth(insns);
         assert(width > 0);
 
         insns += width;
diff --git a/vm/compiler/Frontend.c b/vm/compiler/Frontend.c
index 3c1e837..af704af 100644
--- a/vm/compiler/Frontend.c
+++ b/vm/compiler/Frontend.c
@@ -40,7 +40,7 @@
         }
     }
 
-    dexDecodeInstruction(&gDvm.instrInfo, codePtr, decInsn);
+    dexDecodeInstruction(codePtr, decInsn);
     if (printMe) {
         char *decodedString = dvmCompilerGetDalvikDisassembly(decInsn, NULL);
         LOGD("%p: %#06x %s\n", codePtr, opcode, decodedString);
diff --git a/vm/compiler/InlineTransformation.c b/vm/compiler/InlineTransformation.c
index 951da61..f93558c 100644
--- a/vm/compiler/InlineTransformation.c
+++ b/vm/compiler/InlineTransformation.c
@@ -46,7 +46,7 @@
     MIR *newGetterMIR = dvmCompilerNew(sizeof(MIR), true);
     DecodedInstruction getterInsn;
 
-    dexDecodeInstruction(&gDvm.instrInfo, calleeMethod->insns, &getterInsn);
+    dexDecodeInstruction(calleeMethod->insns, &getterInsn);
 
     if (!dvmCompilerCanIncludeThisInstruction(calleeMethod, &getterInsn))
         return;
@@ -137,7 +137,7 @@
     MIR *newSetterMIR = dvmCompilerNew(sizeof(MIR), true);
     DecodedInstruction setterInsn;
 
-    dexDecodeInstruction(&gDvm.instrInfo, calleeMethod->insns, &setterInsn);
+    dexDecodeInstruction(calleeMethod->insns, &setterInsn);
 
     if (!dvmCompilerCanIncludeThisInstruction(calleeMethod, &setterInsn))
         return;
diff --git a/vm/interp/Jit.c b/vm/interp/Jit.c
index be9d6df..2ae49ca 100644
--- a/vm/interp/Jit.c
+++ b/vm/interp/Jit.c
@@ -288,7 +288,7 @@
     SelfVerificationState state = shadowSpace->selfVerificationState;
 
     DecodedInstruction decInsn;
-    dexDecodeInstruction(&gDvm.instrInfo, pc, &decInsn);
+    dexDecodeInstruction(pc, &decInsn);
 
     //LOGD("### DbgIntp(%d): PC: 0x%x endPC: 0x%x state: %d len: %d %s",
     //    self->threadId, (int)pc, (int)shadowSpace->endPC, state,
@@ -669,7 +669,7 @@
     DecodedInstruction nextDecInsn;
     const u2 *moveResultPC = lastPC + len;
 
-    dexDecodeInstruction(&gDvm.instrInfo, moveResultPC, &nextDecInsn);
+    dexDecodeInstruction(moveResultPC, &nextDecInsn);
     if ((nextDecInsn.opCode != OP_MOVE_RESULT) &&
         (nextDecInsn.opCode != OP_MOVE_RESULT_WIDE) &&
         (nextDecInsn.opCode != OP_MOVE_RESULT_OBJECT))
@@ -685,8 +685,7 @@
     interpState->trace[currTraceRun].frag.isCode = true;
     interpState->totalTraceLen++;
 
-    interpState->currRunLen = dexGetInstrOrTableWidth(gDvm.instrInfo.widths,
-                                                      moveResultPC);
+    interpState->currRunLen = dexGetInstrOrTableWidth(moveResultPC);
 }
 
 /*
@@ -733,7 +732,7 @@
             /* First instruction - just remember the PC and exit */
             if (lastPC == NULL) break;
             /* Grow the trace around the last PC if jitState is kJitTSelect */
-            dexDecodeInstruction(&gDvm.instrInfo, lastPC, &decInsn);
+            dexDecodeInstruction(lastPC, &decInsn);
 
             /*
              * Treat {PACKED,SPARSE}_SWITCH as trace-ending instructions due
@@ -752,7 +751,7 @@
             LOGD("TraceGen: adding %s", dexGetOpcodeName(decInsn.opCode));
 #endif
             flags = dexGetInstrFlags(gDvm.instrInfo.flags, decInsn.opCode);
-            len = dexGetInstrOrTableWidth(gDvm.instrInfo.widths, lastPC);
+            len = dexGetInstrOrTableWidth(lastPC);
             offset = lastPC - interpState->method->insns;
             assert((unsigned) offset <
                    dvmGetMethodInsnsSize(interpState->method));