diff --git a/src/compiler_llvm/method_compiler.cc b/src/compiler_llvm/method_compiler.cc
index ea96b2f..b2dc1f2 100644
--- a/src/compiler_llvm/method_compiler.cc
+++ b/src/compiler_llvm/method_compiler.cc
@@ -216,11 +216,1253 @@
   // Set the IRBuilder insertion point
   irb_.SetInsertPoint(GetBasicBlock(dex_pc));
 
+#define ARGS dex_pc, insn
+
+  // Dispatch the instruction
+  switch (insn->Opcode()) {
+  case Instruction::NOP:
+    EmitInsn_Nop(ARGS);
+    break;
+
+  case Instruction::MOVE:
+  case Instruction::MOVE_FROM16:
+  case Instruction::MOVE_16:
+    EmitInsn_Move(ARGS, kInt);
+    break;
+
+  case Instruction::MOVE_WIDE:
+  case Instruction::MOVE_WIDE_FROM16:
+  case Instruction::MOVE_WIDE_16:
+    EmitInsn_Move(ARGS, kLong);
+    break;
+
+  case Instruction::MOVE_OBJECT:
+  case Instruction::MOVE_OBJECT_FROM16:
+  case Instruction::MOVE_OBJECT_16:
+    EmitInsn_Move(ARGS, kObject);
+    break;
+
+  case Instruction::MOVE_RESULT:
+    EmitInsn_MoveResult(ARGS, kInt);
+    break;
+
+  case Instruction::MOVE_RESULT_WIDE:
+    EmitInsn_MoveResult(ARGS, kLong);
+    break;
+
+  case Instruction::MOVE_RESULT_OBJECT:
+    EmitInsn_MoveResult(ARGS, kObject);
+    break;
+
+  case Instruction::MOVE_EXCEPTION:
+    EmitInsn_MoveException(ARGS);
+    break;
+
+  case Instruction::RETURN_VOID:
+    EmitInsn_ReturnVoid(ARGS);
+    break;
+
+  case Instruction::RETURN:
+  case Instruction::RETURN_WIDE:
+  case Instruction::RETURN_OBJECT:
+    EmitInsn_Return(ARGS);
+    break;
+
+  case Instruction::CONST_4:
+  case Instruction::CONST_16:
+  case Instruction::CONST:
+  case Instruction::CONST_HIGH16:
+    EmitInsn_LoadConstant(ARGS, kInt);
+    break;
+
+  case Instruction::CONST_WIDE_16:
+  case Instruction::CONST_WIDE_32:
+  case Instruction::CONST_WIDE:
+  case Instruction::CONST_WIDE_HIGH16:
+    EmitInsn_LoadConstant(ARGS, kLong);
+    break;
+
+  case Instruction::CONST_STRING:
+  case Instruction::CONST_STRING_JUMBO:
+    EmitInsn_LoadConstantString(ARGS);
+    break;
+
+  case Instruction::CONST_CLASS:
+    EmitInsn_LoadConstantClass(ARGS);
+    break;
+
+  case Instruction::MONITOR_ENTER:
+    EmitInsn_MonitorEnter(ARGS);
+    break;
+
+  case Instruction::MONITOR_EXIT:
+    EmitInsn_MonitorExit(ARGS);
+    break;
+
+  case Instruction::CHECK_CAST:
+    EmitInsn_CheckCast(ARGS);
+    break;
+
+  case Instruction::INSTANCE_OF:
+    EmitInsn_InstanceOf(ARGS);
+    break;
+
+  case Instruction::ARRAY_LENGTH:
+    EmitInsn_ArrayLength(ARGS);
+    break;
+
+  case Instruction::NEW_INSTANCE:
+    EmitInsn_NewInstance(ARGS);
+    break;
+
+  case Instruction::NEW_ARRAY:
+    EmitInsn_NewArray(ARGS);
+    break;
+
+  case Instruction::FILLED_NEW_ARRAY:
+    EmitInsn_FilledNewArray(ARGS, false);
+    break;
+
+  case Instruction::FILLED_NEW_ARRAY_RANGE:
+    EmitInsn_FilledNewArray(ARGS, true);
+    break;
+
+  case Instruction::FILL_ARRAY_DATA:
+    EmitInsn_FillArrayData(ARGS);
+    break;
+
+  case Instruction::THROW:
+    EmitInsn_ThrowException(ARGS);
+    break;
+
+  case Instruction::GOTO:
+  case Instruction::GOTO_16:
+  case Instruction::GOTO_32:
+    EmitInsn_UnconditionalBranch(ARGS);
+    break;
+
+  case Instruction::PACKED_SWITCH:
+    EmitInsn_PackedSwitch(ARGS);
+    break;
+
+  case Instruction::SPARSE_SWITCH:
+    EmitInsn_SparseSwitch(ARGS);
+    break;
+
+  case Instruction::CMPL_FLOAT:
+    EmitInsn_FPCompare(ARGS, kFloat, false);
+    break;
+
+  case Instruction::CMPG_FLOAT:
+    EmitInsn_FPCompare(ARGS, kFloat, true);
+    break;
+
+  case Instruction::CMPL_DOUBLE:
+    EmitInsn_FPCompare(ARGS, kDouble, false);
+    break;
+
+  case Instruction::CMPG_DOUBLE:
+    EmitInsn_FPCompare(ARGS, kDouble, true);
+    break;
+
+  case Instruction::CMP_LONG:
+    EmitInsn_LongCompare(ARGS);
+    break;
+
+  case Instruction::IF_EQ:
+    EmitInsn_BinaryConditionalBranch(ARGS, kCondBranch_EQ);
+    break;
+
+  case Instruction::IF_NE:
+    EmitInsn_BinaryConditionalBranch(ARGS, kCondBranch_NE);
+    break;
+
+  case Instruction::IF_LT:
+    EmitInsn_BinaryConditionalBranch(ARGS, kCondBranch_LT);
+    break;
+
+  case Instruction::IF_GE:
+    EmitInsn_BinaryConditionalBranch(ARGS, kCondBranch_GE);
+    break;
+
+  case Instruction::IF_GT:
+    EmitInsn_BinaryConditionalBranch(ARGS, kCondBranch_GT);
+    break;
+
+  case Instruction::IF_LE:
+    EmitInsn_BinaryConditionalBranch(ARGS, kCondBranch_LE);
+    break;
+
+  case Instruction::IF_EQZ:
+    EmitInsn_UnaryConditionalBranch(ARGS, kCondBranch_EQ);
+    break;
+
+  case Instruction::IF_NEZ:
+    EmitInsn_UnaryConditionalBranch(ARGS, kCondBranch_NE);
+    break;
+
+  case Instruction::IF_LTZ:
+    EmitInsn_UnaryConditionalBranch(ARGS, kCondBranch_LT);
+    break;
+
+  case Instruction::IF_GEZ:
+    EmitInsn_UnaryConditionalBranch(ARGS, kCondBranch_GE);
+    break;
+
+  case Instruction::IF_GTZ:
+    EmitInsn_UnaryConditionalBranch(ARGS, kCondBranch_GT);
+    break;
+
+  case Instruction::IF_LEZ:
+    EmitInsn_UnaryConditionalBranch(ARGS, kCondBranch_LE);
+    break;
+
+  case Instruction::AGET:
+    EmitInsn_AGet(ARGS, kInt);
+    break;
+
+  case Instruction::AGET_WIDE:
+    EmitInsn_AGet(ARGS, kLong);
+    break;
+
+  case Instruction::AGET_OBJECT:
+    EmitInsn_AGet(ARGS, kObject);
+    break;
+
+  case Instruction::AGET_BOOLEAN:
+    EmitInsn_AGet(ARGS, kBoolean);
+    break;
+
+  case Instruction::AGET_BYTE:
+    EmitInsn_AGet(ARGS, kByte);
+    break;
+
+  case Instruction::AGET_CHAR:
+    EmitInsn_AGet(ARGS, kChar);
+    break;
+
+  case Instruction::AGET_SHORT:
+    EmitInsn_AGet(ARGS, kShort);
+    break;
+
+  case Instruction::APUT:
+    EmitInsn_APut(ARGS, kInt);
+    break;
+
+  case Instruction::APUT_WIDE:
+    EmitInsn_APut(ARGS, kLong);
+    break;
+
+  case Instruction::APUT_OBJECT:
+    EmitInsn_APut(ARGS, kObject);
+    break;
+
+  case Instruction::APUT_BOOLEAN:
+    EmitInsn_APut(ARGS, kBoolean);
+    break;
+
+  case Instruction::APUT_BYTE:
+    EmitInsn_APut(ARGS, kByte);
+    break;
+
+  case Instruction::APUT_CHAR:
+    EmitInsn_APut(ARGS, kChar);
+    break;
+
+  case Instruction::APUT_SHORT:
+    EmitInsn_APut(ARGS, kShort);
+    break;
+
+  case Instruction::IGET:
+    EmitInsn_IGet(ARGS, kInt);
+    break;
+
+  case Instruction::IGET_WIDE:
+    EmitInsn_IGet(ARGS, kLong);
+    break;
+
+  case Instruction::IGET_OBJECT:
+    EmitInsn_IGet(ARGS, kObject);
+    break;
+
+  case Instruction::IGET_BOOLEAN:
+    EmitInsn_IGet(ARGS, kBoolean);
+    break;
+
+  case Instruction::IGET_BYTE:
+    EmitInsn_IGet(ARGS, kByte);
+    break;
+
+  case Instruction::IGET_CHAR:
+    EmitInsn_IGet(ARGS, kChar);
+    break;
+
+  case Instruction::IGET_SHORT:
+    EmitInsn_IGet(ARGS, kShort);
+    break;
+
+  case Instruction::IPUT:
+    EmitInsn_IPut(ARGS, kInt);
+    break;
+
+  case Instruction::IPUT_WIDE:
+    EmitInsn_IPut(ARGS, kLong);
+    break;
+
+  case Instruction::IPUT_OBJECT:
+    EmitInsn_IPut(ARGS, kObject);
+    break;
+
+  case Instruction::IPUT_BOOLEAN:
+    EmitInsn_IPut(ARGS, kBoolean);
+    break;
+
+  case Instruction::IPUT_BYTE:
+    EmitInsn_IPut(ARGS, kByte);
+    break;
+
+  case Instruction::IPUT_CHAR:
+    EmitInsn_IPut(ARGS, kChar);
+    break;
+
+  case Instruction::IPUT_SHORT:
+    EmitInsn_IPut(ARGS, kShort);
+    break;
+
+  case Instruction::SGET:
+    EmitInsn_SGet(ARGS, kInt);
+    break;
+
+  case Instruction::SGET_WIDE:
+    EmitInsn_SGet(ARGS, kLong);
+    break;
+
+  case Instruction::SGET_OBJECT:
+    EmitInsn_SGet(ARGS, kObject);
+    break;
+
+  case Instruction::SGET_BOOLEAN:
+    EmitInsn_SGet(ARGS, kBoolean);
+    break;
+
+  case Instruction::SGET_BYTE:
+    EmitInsn_SGet(ARGS, kByte);
+    break;
+
+  case Instruction::SGET_CHAR:
+    EmitInsn_SGet(ARGS, kChar);
+    break;
+
+  case Instruction::SGET_SHORT:
+    EmitInsn_SGet(ARGS, kShort);
+    break;
+
+  case Instruction::SPUT:
+    EmitInsn_SPut(ARGS, kInt);
+    break;
+
+  case Instruction::SPUT_WIDE:
+    EmitInsn_SPut(ARGS, kLong);
+    break;
+
+  case Instruction::SPUT_OBJECT:
+    EmitInsn_SPut(ARGS, kObject);
+    break;
+
+  case Instruction::SPUT_BOOLEAN:
+    EmitInsn_SPut(ARGS, kBoolean);
+    break;
+
+  case Instruction::SPUT_BYTE:
+    EmitInsn_SPut(ARGS, kByte);
+    break;
+
+  case Instruction::SPUT_CHAR:
+    EmitInsn_SPut(ARGS, kChar);
+    break;
+
+  case Instruction::SPUT_SHORT:
+    EmitInsn_SPut(ARGS, kShort);
+    break;
+
+
+  case Instruction::INVOKE_VIRTUAL:
+    EmitInsn_InvokeVirtual(ARGS, false);
+    break;
+
+  case Instruction::INVOKE_SUPER:
+    EmitInsn_InvokeSuper(ARGS, false);
+    break;
+
+  case Instruction::INVOKE_DIRECT:
+    EmitInsn_InvokeDirect(ARGS, false);
+    break;
+
+  case Instruction::INVOKE_STATIC:
+    EmitInsn_InvokeStatic(ARGS, false);
+    break;
+
+  case Instruction::INVOKE_INTERFACE:
+    EmitInsn_InvokeInterface(ARGS, false);
+    break;
+
+  case Instruction::INVOKE_VIRTUAL_RANGE:
+    EmitInsn_InvokeVirtual(ARGS, true);
+    break;
+
+  case Instruction::INVOKE_SUPER_RANGE:
+    EmitInsn_InvokeSuper(ARGS, true);
+    break;
+
+  case Instruction::INVOKE_DIRECT_RANGE:
+    EmitInsn_InvokeDirect(ARGS, true);
+    break;
+
+  case Instruction::INVOKE_STATIC_RANGE:
+    EmitInsn_InvokeStatic(ARGS, true);
+    break;
+
+  case Instruction::INVOKE_INTERFACE_RANGE:
+    EmitInsn_InvokeInterface(ARGS, true);
+    break;
+
+  case Instruction::NEG_INT:
+    EmitInsn_Neg(ARGS, kInt);
+    break;
+
+  case Instruction::NOT_INT:
+    EmitInsn_Not(ARGS, kInt);
+    break;
+
+  case Instruction::NEG_LONG:
+    EmitInsn_Neg(ARGS, kLong);
+    break;
+
+  case Instruction::NOT_LONG:
+    EmitInsn_Not(ARGS, kLong);
+    break;
+
+  case Instruction::NEG_FLOAT:
+    EmitInsn_FNeg(ARGS, kFloat);
+    break;
+
+  case Instruction::NEG_DOUBLE:
+    EmitInsn_FNeg(ARGS, kDouble);
+    break;
+
+  case Instruction::INT_TO_LONG:
+    EmitInsn_SExt(ARGS);
+    break;
+
+  case Instruction::INT_TO_FLOAT:
+    EmitInsn_IntToFP(ARGS, kInt, kFloat);
+    break;
+
+  case Instruction::INT_TO_DOUBLE:
+    EmitInsn_IntToFP(ARGS, kInt, kDouble);
+    break;
+
+  case Instruction::LONG_TO_INT:
+    EmitInsn_Trunc(ARGS);
+    break;
+
+  case Instruction::LONG_TO_FLOAT:
+    EmitInsn_IntToFP(ARGS, kLong, kFloat);
+    break;
+
+  case Instruction::LONG_TO_DOUBLE:
+    EmitInsn_IntToFP(ARGS, kLong, kDouble);
+    break;
+
+  case Instruction::FLOAT_TO_INT:
+    EmitInsn_FPToInt(ARGS, kFloat, kInt);
+    break;
+
+  case Instruction::FLOAT_TO_LONG:
+    EmitInsn_FPToInt(ARGS, kFloat, kLong);
+    break;
+
+  case Instruction::FLOAT_TO_DOUBLE:
+    EmitInsn_FExt(ARGS);
+    break;
+
+  case Instruction::DOUBLE_TO_INT:
+    EmitInsn_FPToInt(ARGS, kDouble, kInt);
+    break;
+
+  case Instruction::DOUBLE_TO_LONG:
+    EmitInsn_FPToInt(ARGS, kDouble, kLong);
+    break;
+
+  case Instruction::DOUBLE_TO_FLOAT:
+    EmitInsn_FTrunc(ARGS);
+    break;
+
+  case Instruction::INT_TO_BYTE:
+    EmitInsn_TruncAndSExt(ARGS, 8);
+    break;
+
+  case Instruction::INT_TO_CHAR:
+    EmitInsn_TruncAndZExt(ARGS, 16);
+    break;
+
+  case Instruction::INT_TO_SHORT:
+    EmitInsn_TruncAndSExt(ARGS, 16);
+    break;
+
+  case Instruction::ADD_INT:
+    EmitInsn_IntArithm(ARGS, kIntArithm_Add, kInt, false);
+    break;
+
+  case Instruction::SUB_INT:
+    EmitInsn_IntArithm(ARGS, kIntArithm_Sub, kInt, false);
+    break;
+
+  case Instruction::MUL_INT:
+    EmitInsn_IntArithm(ARGS, kIntArithm_Mul, kInt, false);
+    break;
+
+  case Instruction::DIV_INT:
+    EmitInsn_IntArithm(ARGS, kIntArithm_Div, kInt, false);
+    break;
+
+  case Instruction::REM_INT:
+    EmitInsn_IntArithm(ARGS, kIntArithm_Rem, kInt, false);
+    break;
+
+  case Instruction::AND_INT:
+    EmitInsn_IntArithm(ARGS, kIntArithm_And, kInt, false);
+    break;
+
+  case Instruction::OR_INT:
+    EmitInsn_IntArithm(ARGS, kIntArithm_Or, kInt, false);
+    break;
+
+  case Instruction::XOR_INT:
+    EmitInsn_IntArithm(ARGS, kIntArithm_Xor, kInt, false);
+    break;
+
+  case Instruction::SHL_INT:
+    EmitInsn_IntArithm(ARGS, kIntArithm_Shl, kInt, false);
+    break;
+
+  case Instruction::SHR_INT:
+    EmitInsn_IntArithm(ARGS, kIntArithm_Shr, kInt, false);
+    break;
+
+  case Instruction::USHR_INT:
+    EmitInsn_IntArithm(ARGS, kIntArithm_UShr, kInt, false);
+    break;
+
+  case Instruction::ADD_LONG:
+    EmitInsn_IntArithm(ARGS, kIntArithm_Add, kLong, false);
+    break;
+
+  case Instruction::SUB_LONG:
+    EmitInsn_IntArithm(ARGS, kIntArithm_Sub, kLong, false);
+    break;
+
+  case Instruction::MUL_LONG:
+    EmitInsn_IntArithm(ARGS, kIntArithm_Mul, kLong, false);
+    break;
+
+  case Instruction::DIV_LONG:
+    EmitInsn_IntArithm(ARGS, kIntArithm_Div, kLong, false);
+    break;
+
+  case Instruction::REM_LONG:
+    EmitInsn_IntArithm(ARGS, kIntArithm_Rem, kLong, false);
+    break;
+
+  case Instruction::AND_LONG:
+    EmitInsn_IntArithm(ARGS, kIntArithm_And, kLong, false);
+    break;
+
+  case Instruction::OR_LONG:
+    EmitInsn_IntArithm(ARGS, kIntArithm_Or, kLong, false);
+    break;
+
+  case Instruction::XOR_LONG:
+    EmitInsn_IntArithm(ARGS, kIntArithm_Xor, kLong, false);
+    break;
+
+  case Instruction::SHL_LONG:
+    EmitInsn_IntArithm(ARGS, kIntArithm_Shl, kLong, false);
+    break;
+
+  case Instruction::SHR_LONG:
+    EmitInsn_IntArithm(ARGS, kIntArithm_Shr, kLong, false);
+    break;
+
+  case Instruction::USHR_LONG:
+    EmitInsn_IntArithm(ARGS, kIntArithm_UShr, kLong, false);
+    break;
+
+  case Instruction::ADD_FLOAT:
+    EmitInsn_FPArithm(ARGS, kFPArithm_Add, kFloat, false);
+    break;
+
+  case Instruction::SUB_FLOAT:
+    EmitInsn_FPArithm(ARGS, kFPArithm_Sub, kFloat, false);
+    break;
+
+  case Instruction::MUL_FLOAT:
+    EmitInsn_FPArithm(ARGS, kFPArithm_Mul, kFloat, false);
+    break;
+
+  case Instruction::DIV_FLOAT:
+    EmitInsn_FPArithm(ARGS, kFPArithm_Div, kFloat, false);
+    break;
+
+  case Instruction::REM_FLOAT:
+    EmitInsn_FPArithm(ARGS, kFPArithm_Rem, kFloat, false);
+    break;
+
+  case Instruction::ADD_DOUBLE:
+    EmitInsn_FPArithm(ARGS, kFPArithm_Add, kDouble, false);
+    break;
+
+  case Instruction::SUB_DOUBLE:
+    EmitInsn_FPArithm(ARGS, kFPArithm_Sub, kDouble, false);
+    break;
+
+  case Instruction::MUL_DOUBLE:
+    EmitInsn_FPArithm(ARGS, kFPArithm_Mul, kDouble, false);
+    break;
+
+  case Instruction::DIV_DOUBLE:
+    EmitInsn_FPArithm(ARGS, kFPArithm_Div, kDouble, false);
+    break;
+
+  case Instruction::REM_DOUBLE:
+    EmitInsn_FPArithm(ARGS, kFPArithm_Rem, kDouble, false);
+    break;
+
+  case Instruction::ADD_INT_2ADDR:
+    EmitInsn_IntArithm(ARGS, kIntArithm_Add, kInt, true);
+    break;
+
+  case Instruction::SUB_INT_2ADDR:
+    EmitInsn_IntArithm(ARGS, kIntArithm_Sub, kInt, true);
+    break;
+
+  case Instruction::MUL_INT_2ADDR:
+    EmitInsn_IntArithm(ARGS, kIntArithm_Mul, kInt, true);
+    break;
+
+  case Instruction::DIV_INT_2ADDR:
+    EmitInsn_IntArithm(ARGS, kIntArithm_Div, kInt, true);
+    break;
+
+  case Instruction::REM_INT_2ADDR:
+    EmitInsn_IntArithm(ARGS, kIntArithm_Rem, kInt, true);
+    break;
+
+  case Instruction::AND_INT_2ADDR:
+    EmitInsn_IntArithm(ARGS, kIntArithm_And, kInt, true);
+    break;
+
+  case Instruction::OR_INT_2ADDR:
+    EmitInsn_IntArithm(ARGS, kIntArithm_Or, kInt, true);
+    break;
+
+  case Instruction::XOR_INT_2ADDR:
+    EmitInsn_IntArithm(ARGS, kIntArithm_Xor, kInt, true);
+    break;
+
+  case Instruction::SHL_INT_2ADDR:
+    EmitInsn_IntArithm(ARGS, kIntArithm_Shl, kInt, true);
+    break;
+
+  case Instruction::SHR_INT_2ADDR:
+    EmitInsn_IntArithm(ARGS, kIntArithm_Shr, kInt, true);
+    break;
+
+  case Instruction::USHR_INT_2ADDR:
+    EmitInsn_IntArithm(ARGS, kIntArithm_UShr, kInt, true);
+    break;
+
+  case Instruction::ADD_LONG_2ADDR:
+    EmitInsn_IntArithm(ARGS, kIntArithm_Add, kLong, true);
+    break;
+
+  case Instruction::SUB_LONG_2ADDR:
+    EmitInsn_IntArithm(ARGS, kIntArithm_Sub, kLong, true);
+    break;
+
+  case Instruction::MUL_LONG_2ADDR:
+    EmitInsn_IntArithm(ARGS, kIntArithm_Mul, kLong, true);
+    break;
+
+  case Instruction::DIV_LONG_2ADDR:
+    EmitInsn_IntArithm(ARGS, kIntArithm_Div, kLong, true);
+    break;
+
+  case Instruction::REM_LONG_2ADDR:
+    EmitInsn_IntArithm(ARGS, kIntArithm_Rem, kLong, true);
+    break;
+
+  case Instruction::AND_LONG_2ADDR:
+    EmitInsn_IntArithm(ARGS, kIntArithm_And, kLong, true);
+    break;
+
+  case Instruction::OR_LONG_2ADDR:
+    EmitInsn_IntArithm(ARGS, kIntArithm_Or, kLong, true);
+    break;
+
+  case Instruction::XOR_LONG_2ADDR:
+    EmitInsn_IntArithm(ARGS, kIntArithm_Xor, kLong, true);
+    break;
+
+  case Instruction::SHL_LONG_2ADDR:
+    EmitInsn_IntArithm(ARGS, kIntArithm_Shl, kLong, true);
+    break;
+
+  case Instruction::SHR_LONG_2ADDR:
+    EmitInsn_IntArithm(ARGS, kIntArithm_Shr, kLong, true);
+    break;
+
+  case Instruction::USHR_LONG_2ADDR:
+    EmitInsn_IntArithm(ARGS, kIntArithm_UShr, kLong, true);
+    break;
+
+  case Instruction::ADD_FLOAT_2ADDR:
+    EmitInsn_FPArithm(ARGS, kFPArithm_Add, kFloat, true);
+    break;
+
+  case Instruction::SUB_FLOAT_2ADDR:
+    EmitInsn_FPArithm(ARGS, kFPArithm_Sub, kFloat, true);
+    break;
+
+  case Instruction::MUL_FLOAT_2ADDR:
+    EmitInsn_FPArithm(ARGS, kFPArithm_Mul, kFloat, true);
+    break;
+
+  case Instruction::DIV_FLOAT_2ADDR:
+    EmitInsn_FPArithm(ARGS, kFPArithm_Div, kFloat, true);
+    break;
+
+  case Instruction::REM_FLOAT_2ADDR:
+    EmitInsn_FPArithm(ARGS, kFPArithm_Rem, kFloat, true);
+    break;
+
+  case Instruction::ADD_DOUBLE_2ADDR:
+    EmitInsn_FPArithm(ARGS, kFPArithm_Add, kDouble, true);
+    break;
+
+  case Instruction::SUB_DOUBLE_2ADDR:
+    EmitInsn_FPArithm(ARGS, kFPArithm_Sub, kDouble, true);
+    break;
+
+  case Instruction::MUL_DOUBLE_2ADDR:
+    EmitInsn_FPArithm(ARGS, kFPArithm_Mul, kDouble, true);
+    break;
+
+  case Instruction::DIV_DOUBLE_2ADDR:
+    EmitInsn_FPArithm(ARGS, kFPArithm_Div, kDouble, true);
+    break;
+
+  case Instruction::REM_DOUBLE_2ADDR:
+    EmitInsn_FPArithm(ARGS, kFPArithm_Rem, kDouble, true);
+    break;
+
+  case Instruction::ADD_INT_LIT16:
+  case Instruction::ADD_INT_LIT8:
+    EmitInsn_IntArithmImmediate(ARGS, kIntArithm_Add);
+    break;
+
+  case Instruction::RSUB_INT:
+  case Instruction::RSUB_INT_LIT8:
+    EmitInsn_RSubImmediate(ARGS);
+    break;
+
+  case Instruction::MUL_INT_LIT16:
+  case Instruction::MUL_INT_LIT8:
+    EmitInsn_IntArithmImmediate(ARGS, kIntArithm_Mul);
+    break;
+
+  case Instruction::DIV_INT_LIT16:
+  case Instruction::DIV_INT_LIT8:
+    EmitInsn_IntArithmImmediate(ARGS, kIntArithm_Div);
+    break;
+
+  case Instruction::REM_INT_LIT16:
+  case Instruction::REM_INT_LIT8:
+    EmitInsn_IntArithmImmediate(ARGS, kIntArithm_Rem);
+    break;
+
+  case Instruction::AND_INT_LIT16:
+  case Instruction::AND_INT_LIT8:
+    EmitInsn_IntArithmImmediate(ARGS, kIntArithm_And);
+    break;
+
+  case Instruction::OR_INT_LIT16:
+  case Instruction::OR_INT_LIT8:
+    EmitInsn_IntArithmImmediate(ARGS, kIntArithm_Or);
+    break;
+
+  case Instruction::XOR_INT_LIT16:
+  case Instruction::XOR_INT_LIT8:
+    EmitInsn_IntArithmImmediate(ARGS, kIntArithm_Xor);
+    break;
+
+  case Instruction::SHL_INT_LIT8:
+    EmitInsn_IntArithmImmediate(ARGS, kIntArithm_Shl);
+    break;
+
+  case Instruction::SHR_INT_LIT8:
+    EmitInsn_IntArithmImmediate(ARGS, kIntArithm_Shr);
+    break;
+
+  case Instruction::USHR_INT_LIT8:
+    EmitInsn_IntArithmImmediate(ARGS, kIntArithm_UShr);
+    break;
+
+  case Instruction::UNUSED_3E:
+  case Instruction::UNUSED_3F:
+  case Instruction::UNUSED_40:
+  case Instruction::UNUSED_41:
+  case Instruction::UNUSED_42:
+  case Instruction::UNUSED_43:
+  case Instruction::UNUSED_73:
+  case Instruction::UNUSED_79:
+  case Instruction::UNUSED_7A:
+  case Instruction::UNUSED_E3:
+  case Instruction::UNUSED_E4:
+  case Instruction::UNUSED_E5:
+  case Instruction::UNUSED_E6:
+  case Instruction::UNUSED_E7:
+  case Instruction::UNUSED_E8:
+  case Instruction::UNUSED_E9:
+  case Instruction::UNUSED_EA:
+  case Instruction::UNUSED_EB:
+  case Instruction::UNUSED_EC:
+  case Instruction::THROW_VERIFICATION_ERROR:
+  case Instruction::UNUSED_EE:
+  case Instruction::UNUSED_EF:
+  case Instruction::UNUSED_F0:
+  case Instruction::UNUSED_F1:
+  case Instruction::UNUSED_F2:
+  case Instruction::UNUSED_F3:
+  case Instruction::UNUSED_F4:
+  case Instruction::UNUSED_F5:
+  case Instruction::UNUSED_F6:
+  case Instruction::UNUSED_F7:
+  case Instruction::UNUSED_F8:
+  case Instruction::UNUSED_F9:
+  case Instruction::UNUSED_FA:
+  case Instruction::UNUSED_FB:
+  case Instruction::UNUSED_FC:
+  case Instruction::UNUSED_FD:
+  case Instruction::UNUSED_FE:
+  case Instruction::UNUSED_FF:
+    LOG(FATAL) << "Dex file contains UNUSED bytecode: " << insn->Opcode();
+    break;
+  }
+
+#undef ARGS
+}
+
+
+void MethodCompiler::EmitInsn_Nop(uint32_t dex_pc,
+                                  Instruction const* insn) {
   // UNIMPLEMENTED(WARNING);
   irb_.CreateUnreachable();
 }
 
 
+void MethodCompiler::EmitInsn_Move(uint32_t dex_pc,
+                                   Instruction const* insn,
+                                   JType jty) {
+  // UNIMPLEMENTED(WARNING);
+  irb_.CreateBr(GetNextBasicBlock(dex_pc));
+}
+
+
+void MethodCompiler::EmitInsn_MoveResult(uint32_t dex_pc,
+                                         Instruction const* insn,
+                                         JType jty) {
+  // UNIMPLEMENTED(WARNING);
+  irb_.CreateBr(GetNextBasicBlock(dex_pc));
+}
+
+
+void MethodCompiler::EmitInsn_MoveException(uint32_t dex_pc,
+                                            Instruction const* insn) {
+  // UNIMPLEMENTED(WARNING);
+  irb_.CreateBr(GetNextBasicBlock(dex_pc));
+}
+
+
+void MethodCompiler::EmitInsn_ThrowException(uint32_t dex_pc,
+                                             Instruction const* insn) {
+  // UNIMPLEMENTED(WARNING);
+  irb_.CreateUnreachable();
+}
+
+
+void MethodCompiler::EmitInsn_ReturnVoid(uint32_t dex_pc,
+                                         Instruction const* insn) {
+  // UNIMPLEMENTED(WARNING);
+  irb_.CreateUnreachable();
+}
+
+
+void MethodCompiler::EmitInsn_Return(uint32_t dex_pc,
+                                     Instruction const* insn) {
+  // UNIMPLEMENTED(WARNING);
+  irb_.CreateUnreachable();
+}
+
+
+void MethodCompiler::EmitInsn_LoadConstant(uint32_t dex_pc,
+                                           Instruction const* insn,
+                                           JType imm_jty) {
+  // UNIMPLEMENTED(WARNING);
+  irb_.CreateBr(GetNextBasicBlock(dex_pc));
+}
+
+
+void MethodCompiler::EmitInsn_LoadConstantString(uint32_t dex_pc,
+                                                 Instruction const* insn) {
+  // UNIMPLEMENTED(WARNING);
+  irb_.CreateBr(GetNextBasicBlock(dex_pc));
+}
+
+
+void MethodCompiler::EmitInsn_LoadConstantClass(uint32_t dex_pc,
+                                                Instruction const* insn) {
+  // UNIMPLEMENTED(WARNING);
+  irb_.CreateBr(GetNextBasicBlock(dex_pc));
+}
+
+
+void MethodCompiler::EmitInsn_MonitorEnter(uint32_t dex_pc,
+                                           Instruction const* insn) {
+  // UNIMPLEMENTED(WARNING);
+  irb_.CreateBr(GetNextBasicBlock(dex_pc));
+}
+
+
+void MethodCompiler::EmitInsn_MonitorExit(uint32_t dex_pc,
+                                          Instruction const* insn) {
+  // UNIMPLEMENTED(WARNING);
+  irb_.CreateBr(GetNextBasicBlock(dex_pc));
+}
+
+
+void MethodCompiler::EmitInsn_CheckCast(uint32_t dex_pc,
+                                        Instruction const* insn) {
+  // UNIMPLEMENTED(WARNING);
+  irb_.CreateBr(GetNextBasicBlock(dex_pc));
+}
+
+
+void MethodCompiler::EmitInsn_InstanceOf(uint32_t dex_pc,
+                                         Instruction const* insn) {
+  // UNIMPLEMENTED(WARNING);
+  irb_.CreateBr(GetNextBasicBlock(dex_pc));
+}
+
+
+void MethodCompiler::EmitInsn_ArrayLength(uint32_t dex_pc,
+                                          Instruction const* insn) {
+  // UNIMPLEMENTED(WARNING);
+  irb_.CreateBr(GetNextBasicBlock(dex_pc));
+}
+
+
+void MethodCompiler::EmitInsn_NewInstance(uint32_t dex_pc,
+                                          Instruction const* insn) {
+  // UNIMPLEMENTED(WARNING);
+  irb_.CreateBr(GetNextBasicBlock(dex_pc));
+}
+
+
+void MethodCompiler::EmitInsn_NewArray(uint32_t dex_pc,
+                                       Instruction const* insn) {
+  // UNIMPLEMENTED(WARNING);
+  irb_.CreateBr(GetNextBasicBlock(dex_pc));
+}
+
+
+void MethodCompiler::EmitInsn_FilledNewArray(uint32_t dex_pc,
+                                             Instruction const* insn,
+                                             bool is_range) {
+  // UNIMPLEMENTED(WARNING);
+  irb_.CreateBr(GetNextBasicBlock(dex_pc));
+}
+
+
+void MethodCompiler::EmitInsn_FillArrayData(uint32_t dex_pc,
+                                            Instruction const* insn) {
+  // UNIMPLEMENTED(WARNING);
+  irb_.CreateBr(GetNextBasicBlock(dex_pc));
+}
+
+
+void MethodCompiler::EmitInsn_UnconditionalBranch(uint32_t dex_pc,
+                                                  Instruction const* insn) {
+  // UNIMPLEMENTED(WARNING);
+  irb_.CreateUnreachable();
+}
+
+
+void MethodCompiler::EmitInsn_PackedSwitch(uint32_t dex_pc,
+                                           Instruction const* insn) {
+  // UNIMPLEMENTED(WARNING);
+  irb_.CreateUnreachable();
+}
+
+
+void MethodCompiler::EmitInsn_SparseSwitch(uint32_t dex_pc,
+                                           Instruction const* insn) {
+  // UNIMPLEMENTED(WARNING);
+  irb_.CreateUnreachable();
+}
+
+
+void MethodCompiler::EmitInsn_FPCompare(uint32_t dex_pc,
+                                        Instruction const* insn,
+                                        JType fp_jty,
+                                        bool gt_bias) {
+  // UNIMPLEMENTED(WARNING);
+  irb_.CreateBr(GetNextBasicBlock(dex_pc));
+}
+
+
+void MethodCompiler::EmitInsn_LongCompare(uint32_t dex_pc,
+                                          Instruction const* insn) {
+  // UNIMPLEMENTED(WARNING);
+  irb_.CreateBr(GetNextBasicBlock(dex_pc));
+}
+
+
+void MethodCompiler::EmitInsn_BinaryConditionalBranch(uint32_t dex_pc,
+                                                      Instruction const* insn,
+                                                      CondBranchKind cond) {
+  // UNIMPLEMENTED(WARNING);
+  irb_.CreateUnreachable();
+}
+
+
+void MethodCompiler::EmitInsn_UnaryConditionalBranch(uint32_t dex_pc,
+                                                     Instruction const* insn,
+                                                     CondBranchKind cond) {
+  // UNIMPLEMENTED(WARNING);
+  irb_.CreateUnreachable();
+}
+
+
+void MethodCompiler::EmitInsn_AGet(uint32_t dex_pc,
+                                   Instruction const* insn,
+                                   JType elem_jty) {
+  // UNIMPLEMENTED(WARNING);
+  irb_.CreateBr(GetNextBasicBlock(dex_pc));
+}
+
+
+void MethodCompiler::EmitInsn_APut(uint32_t dex_pc,
+                                   Instruction const* insn,
+                                   JType elem_jty) {
+  // UNIMPLEMENTED(WARNING);
+  irb_.CreateBr(GetNextBasicBlock(dex_pc));
+}
+
+
+void MethodCompiler::EmitInsn_IGet(uint32_t dex_pc,
+                                   Instruction const* insn,
+                                   JType field_jty) {
+  // UNIMPLEMENTED(WARNING);
+  irb_.CreateBr(GetNextBasicBlock(dex_pc));
+}
+
+
+void MethodCompiler::EmitInsn_IPut(uint32_t dex_pc,
+                                   Instruction const* insn,
+                                   JType field_jty) {
+  // UNIMPLEMENTED(WARNING);
+  irb_.CreateBr(GetNextBasicBlock(dex_pc));
+}
+
+
+void MethodCompiler::EmitInsn_SGet(uint32_t dex_pc,
+                                   Instruction const* insn,
+                                   JType field_jty) {
+  // UNIMPLEMENTED(WARNING);
+  irb_.CreateBr(GetNextBasicBlock(dex_pc));
+}
+
+
+void MethodCompiler::EmitInsn_SPut(uint32_t dex_pc,
+                                   Instruction const* insn,
+                                   JType field_jty) {
+  // UNIMPLEMENTED(WARNING);
+  irb_.CreateBr(GetNextBasicBlock(dex_pc));
+}
+
+
+void MethodCompiler::EmitInsn_InvokeVirtual(uint32_t dex_pc,
+                                            Instruction const* insn,
+                                            bool is_range) {
+  // UNIMPLEMENTED(WARNING);
+  irb_.CreateBr(GetNextBasicBlock(dex_pc));
+}
+
+
+void MethodCompiler::EmitInsn_InvokeSuper(uint32_t dex_pc,
+                                          Instruction const* insn,
+                                          bool is_range) {
+  // UNIMPLEMENTED(WARNING);
+  irb_.CreateBr(GetNextBasicBlock(dex_pc));
+}
+
+
+void MethodCompiler::EmitInsn_InvokeDirect(uint32_t dex_pc,
+                                           Instruction const* insn,
+                                           bool is_range) {
+  // UNIMPLEMENTED(WARNING);
+  irb_.CreateBr(GetNextBasicBlock(dex_pc));
+}
+
+
+void MethodCompiler::EmitInsn_InvokeStatic(uint32_t dex_pc,
+                                           Instruction const* insn,
+                                           bool is_range) {
+  // UNIMPLEMENTED(WARNING);
+  irb_.CreateBr(GetNextBasicBlock(dex_pc));
+}
+
+
+void MethodCompiler::EmitInsn_InvokeInterface(uint32_t dex_pc,
+                                              Instruction const* insn,
+                                              bool is_range) {
+  // UNIMPLEMENTED(WARNING);
+  irb_.CreateBr(GetNextBasicBlock(dex_pc));
+}
+
+
+void MethodCompiler::EmitInsn_Neg(uint32_t dex_pc,
+                                  Instruction const* insn,
+                                  JType op_jty) {
+  // UNIMPLEMENTED(WARNING);
+  irb_.CreateBr(GetNextBasicBlock(dex_pc));
+}
+
+
+void MethodCompiler::EmitInsn_Not(uint32_t dex_pc,
+                                  Instruction const* insn,
+                                  JType op_jty) {
+  // UNIMPLEMENTED(WARNING);
+  irb_.CreateBr(GetNextBasicBlock(dex_pc));
+}
+
+
+void MethodCompiler::EmitInsn_SExt(uint32_t dex_pc,
+                                   Instruction const* insn) {
+  // UNIMPLEMENTED(WARNING);
+  irb_.CreateBr(GetNextBasicBlock(dex_pc));
+}
+
+
+void MethodCompiler::EmitInsn_Trunc(uint32_t dex_pc,
+                                    Instruction const* insn) {
+  // UNIMPLEMENTED(WARNING);
+  irb_.CreateBr(GetNextBasicBlock(dex_pc));
+}
+
+
+void MethodCompiler::EmitInsn_TruncAndSExt(uint32_t dex_pc,
+                                           Instruction const* insn,
+                                           unsigned N) {
+  // UNIMPLEMENTED(WARNING);
+  irb_.CreateBr(GetNextBasicBlock(dex_pc));
+}
+
+
+void MethodCompiler::EmitInsn_TruncAndZExt(uint32_t dex_pc,
+                                           Instruction const* insn,
+                                           unsigned N) {
+  // UNIMPLEMENTED(WARNING);
+  irb_.CreateBr(GetNextBasicBlock(dex_pc));
+}
+
+
+void MethodCompiler::EmitInsn_FNeg(uint32_t dex_pc,
+                                   Instruction const* insn,
+                                   JType op_jty) {
+  // UNIMPLEMENTED(WARNING);
+  irb_.CreateBr(GetNextBasicBlock(dex_pc));
+}
+
+
+void MethodCompiler::EmitInsn_IntToFP(uint32_t dex_pc,
+                                      Instruction const* insn,
+                                      JType src_jty,
+                                      JType dest_jty) {
+  // UNIMPLEMENTED(WARNING);
+  irb_.CreateBr(GetNextBasicBlock(dex_pc));
+}
+
+
+void MethodCompiler::EmitInsn_FPToInt(uint32_t dex_pc,
+                                      Instruction const* insn,
+                                      JType src_jty,
+                                      JType dest_jty) {
+  // UNIMPLEMENTED(WARNING);
+  irb_.CreateBr(GetNextBasicBlock(dex_pc));
+}
+
+
+void MethodCompiler::EmitInsn_FExt(uint32_t dex_pc,
+                                   Instruction const* insn) {
+  // UNIMPLEMENTED(WARNING);
+  irb_.CreateBr(GetNextBasicBlock(dex_pc));
+}
+
+
+void MethodCompiler::EmitInsn_FTrunc(uint32_t dex_pc,
+                                     Instruction const* insn) {
+  // UNIMPLEMENTED(WARNING);
+  irb_.CreateBr(GetNextBasicBlock(dex_pc));
+}
+
+
+void MethodCompiler::EmitInsn_IntArithm(uint32_t dex_pc,
+                                        Instruction const* insn,
+                                        IntArithmKind arithm,
+                                        JType op_jty,
+                                        bool is_2addr) {
+  // UNIMPLEMENTED(WARNING);
+  irb_.CreateBr(GetNextBasicBlock(dex_pc));
+}
+
+
+void MethodCompiler::EmitInsn_IntArithmImmediate(uint32_t dex_pc,
+                                                 Instruction const* insn,
+                                                 IntArithmKind arithm) {
+  // UNIMPLEMENTED(WARNING);
+  irb_.CreateBr(GetNextBasicBlock(dex_pc));
+}
+
+
+void MethodCompiler::EmitInsn_RSubImmediate(uint32_t dex_pc,
+                                            Instruction const* insn) {
+  // UNIMPLEMENTED(WARNING);
+  irb_.CreateBr(GetNextBasicBlock(dex_pc));
+}
+
+
+void MethodCompiler::EmitInsn_FPArithm(uint32_t dex_pc,
+                                       Instruction const* insn,
+                                       FPArithmKind arithm,
+                                       JType op_jty,
+                                       bool is_2addr) {
+  // UNIMPLEMENTED(WARNING);
+  irb_.CreateBr(GetNextBasicBlock(dex_pc));
+}
+
+
 CompiledMethod *MethodCompiler::Compile() {
   // Code generation
   CreateFunction();
diff --git a/src/compiler_llvm/method_compiler.h b/src/compiler_llvm/method_compiler.h
index f9e73f9..719ef8b 100644
--- a/src/compiler_llvm/method_compiler.h
+++ b/src/compiler_llvm/method_compiler.h
@@ -126,14 +126,143 @@
 
  private:
   void CreateFunction();
-
-
   void EmitPrologue();
   void EmitPrologueLastBranch();
   void EmitPrologueAssignArgRegister();
   void EmitInstructions();
   void EmitInstruction(uint32_t dex_pc, Instruction const* insn);
 
+  enum CondBranchKind {
+    kCondBranch_EQ,
+    kCondBranch_NE,
+    kCondBranch_LT,
+    kCondBranch_GE,
+    kCondBranch_GT,
+    kCondBranch_LE,
+  };
+
+  enum IntArithmKind {
+    kIntArithm_Add,
+    kIntArithm_Sub,
+    kIntArithm_Mul,
+    kIntArithm_Div,
+    kIntArithm_Rem,
+    kIntArithm_And,
+    kIntArithm_Or,
+    kIntArithm_Xor,
+    kIntArithm_Shl,
+    kIntArithm_Shr,
+    kIntArithm_UShr,
+  };
+
+  enum FPArithmKind {
+    kFPArithm_Add,
+    kFPArithm_Sub,
+    kFPArithm_Mul,
+    kFPArithm_Div,
+    kFPArithm_Rem,
+  };
+
+#define GEN_INSN_ARGS uint32_t dex_pc, Instruction const* insn
+
+  // NOP, PAYLOAD (unreachable) instructions
+  void EmitInsn_Nop(GEN_INSN_ARGS);
+
+  // MOVE, MOVE_RESULT instructions
+  void EmitInsn_Move(GEN_INSN_ARGS, JType jty);
+  void EmitInsn_MoveResult(GEN_INSN_ARGS, JType jty);
+
+  // MOVE_EXCEPTION, THROW instructions
+  void EmitInsn_MoveException(GEN_INSN_ARGS);
+  void EmitInsn_ThrowException(GEN_INSN_ARGS);
+
+  // RETURN instructions
+  void EmitInsn_ReturnVoid(GEN_INSN_ARGS);
+  void EmitInsn_Return(GEN_INSN_ARGS);
+
+  // CONST, CONST_CLASS, CONST_STRING instructions
+  void EmitInsn_LoadConstant(GEN_INSN_ARGS, JType imm_jty);
+  void EmitInsn_LoadConstantString(GEN_INSN_ARGS);
+  void EmitInsn_LoadConstantClass(GEN_INSN_ARGS);
+
+  // MONITOR_ENTER, MONITOR_EXIT instructions
+  void EmitInsn_MonitorEnter(GEN_INSN_ARGS);
+  void EmitInsn_MonitorExit(GEN_INSN_ARGS);
+
+  // CHECK_CAST, INSTANCE_OF instructions
+  void EmitInsn_CheckCast(GEN_INSN_ARGS);
+  void EmitInsn_InstanceOf(GEN_INSN_ARGS);
+
+  // NEW_INSTANCE instructions
+  void EmitInsn_NewInstance(GEN_INSN_ARGS);
+
+  // ARRAY_LEN, NEW_ARRAY, FILLED_NEW_ARRAY, FILL_ARRAY_DATA instructions
+  void EmitInsn_ArrayLength(GEN_INSN_ARGS);
+  void EmitInsn_NewArray(GEN_INSN_ARGS);
+  void EmitInsn_FilledNewArray(GEN_INSN_ARGS, bool is_range);
+  void EmitInsn_FillArrayData(GEN_INSN_ARGS);
+
+  // GOTO, IF_TEST, IF_TESTZ instructions
+  void EmitInsn_UnconditionalBranch(GEN_INSN_ARGS);
+  void EmitInsn_BinaryConditionalBranch(GEN_INSN_ARGS, CondBranchKind cond);
+  void EmitInsn_UnaryConditionalBranch(GEN_INSN_ARGS, CondBranchKind cond);
+
+  // PACKED_SWITCH, SPARSE_SWITCH instrutions
+  void EmitInsn_PackedSwitch(GEN_INSN_ARGS);
+  void EmitInsn_SparseSwitch(GEN_INSN_ARGS);
+
+  // CMPX_FLOAT, CMPX_DOUBLE, CMP_LONG instructions
+  void EmitInsn_FPCompare(GEN_INSN_ARGS, JType fp_jty, bool gt_bias);
+  void EmitInsn_LongCompare(GEN_INSN_ARGS);
+
+  // AGET, APUT instrutions
+  void EmitInsn_AGet(GEN_INSN_ARGS, JType elem_jty);
+  void EmitInsn_APut(GEN_INSN_ARGS, JType elem_jty);
+
+  // IGET, IPUT instructions
+  void EmitInsn_IGet(GEN_INSN_ARGS, JType field_jty);
+  void EmitInsn_IPut(GEN_INSN_ARGS, JType field_jty);
+
+  // SGET, SPUT instructions
+  void EmitInsn_SGet(GEN_INSN_ARGS, JType field_jty);
+  void EmitInsn_SPut(GEN_INSN_ARGS, JType field_jty);
+
+  // INVOKE instructions
+  void EmitInsn_InvokeVirtual(GEN_INSN_ARGS, bool is_range);
+  void EmitInsn_InvokeSuper(GEN_INSN_ARGS, bool is_range);
+  void EmitInsn_InvokeDirect(GEN_INSN_ARGS, bool is_range);
+  void EmitInsn_InvokeStatic(GEN_INSN_ARGS, bool is_range);
+  void EmitInsn_InvokeInterface(GEN_INSN_ARGS, bool is_range);
+
+  // Unary instructions
+  void EmitInsn_Neg(GEN_INSN_ARGS, JType op_jty);
+  void EmitInsn_Not(GEN_INSN_ARGS, JType op_jty);
+  void EmitInsn_SExt(GEN_INSN_ARGS);
+  void EmitInsn_Trunc(GEN_INSN_ARGS);
+  void EmitInsn_TruncAndSExt(GEN_INSN_ARGS, unsigned N);
+  void EmitInsn_TruncAndZExt(GEN_INSN_ARGS, unsigned N);
+
+  void EmitInsn_FNeg(GEN_INSN_ARGS, JType op_jty);
+  void EmitInsn_IntToFP(GEN_INSN_ARGS, JType src_jty, JType dest_jty);
+  void EmitInsn_FPToInt(GEN_INSN_ARGS, JType src_jty, JType dest_jty);
+  void EmitInsn_FExt(GEN_INSN_ARGS);
+  void EmitInsn_FTrunc(GEN_INSN_ARGS);
+
+  // Integer binary arithmetic instructions
+  void EmitInsn_IntArithm(GEN_INSN_ARGS, IntArithmKind arithm,
+                          JType op_jty, bool is_2addr);
+
+  void EmitInsn_IntArithmImmediate(GEN_INSN_ARGS, IntArithmKind arithm);
+
+  void EmitInsn_RSubImmediate(GEN_INSN_ARGS);
+
+
+  // Floating-point binary arithmetic instructions
+  void EmitInsn_FPArithm(GEN_INSN_ARGS, FPArithmKind arithm,
+                         JType op_jty, bool is_2addr);
+
+#undef GEN_INSN_ARGS
+
 
   // Code generation helper function
 
@@ -145,7 +274,7 @@
 
   void EmitBranchExceptionLandingPad(uint32_t dex_pc);
 
-  void EmitGuard_GarbageCollectionSuspend(uint32_t addr);
+  void EmitGuard_GarbageCollectionSuspend(uint32_t dex_pc);
 
 
   // Basic block helper functions