static void test() { #define M68K_CODE "\xf0\x10\xf0\x00\x48\xaf\xff\xff\x7f\xff\x11\xb0\x01\x37\x7f\xff\xff\xff\x12\x34\x56\x78\x01\x33\x10\x10\x10\x10\x32\x32\x32\x32\x4C\x00\x54\x04\x48\xe7\xe0\x30\x4C\xDF\x0C\x07\xd4\x40\x87\x5a\x4e\x71\x02\xb4\xc0\xde\xc0\xde\x5c\x00\x1d\x80\x71\x12\x01\x23\xf2\x3c\x44\x22\x40\x49\x0e\x56\x54\xc5\xf2\x3c\x44\x00\x44\x7a\x00\x00\xf2\x00\x0a\x28\x4E\xB9\x00\x00\x00\x12\x4E\x75" struct platform platforms[] = { { CS_ARCH_M68K, (cs_mode)(CS_MODE_BIG_ENDIAN | CS_MODE_M68K_040), (unsigned char*)M68K_CODE, sizeof(M68K_CODE) - 1, "M68K", }, }; uint64_t address = 0x01000; cs_insn *insn; int i; size_t count; for (i = 0; i < sizeof(platforms)/sizeof(platforms[0]); i++) { cs_err err = cs_open(platforms[i].arch, platforms[i].mode, &handle); if (err) { printf("Failed on cs_open() with error returned: %u\n", err); abort(); } cs_option(handle, CS_OPT_DETAIL, CS_OPT_ON); count = cs_disasm(handle, platforms[i].code, platforms[i].size, address, 0, &insn); if (count) { size_t j; printf("****************\n"); printf("Platform: %s\n", platforms[i].comment); print_string_hex("Code: ", platforms[i].code, platforms[i].size); printf("Disasm:\n"); for (j = 0; j < count; j++) { assert(address == insn[j].address && "this means the size of the previous instruction was incorrect"); address += insn[j].size; printf("0x%" PRIx64 ":\t%s\t%s\n", insn[j].address, insn[j].mnemonic, insn[j].op_str); print_insn_detail(&insn[j]); } printf("0x%" PRIx64 ":\n", insn[j-1].address + insn[j-1].size); // free memory allocated by cs_disasm() cs_free(insn, count); } else { printf("****************\n"); printf("Platform: %s\n", platforms[i].comment); print_string_hex("Code:", platforms[i].code, platforms[i].size); printf("ERROR: Failed to disasm given code!\n"); abort(); } printf("\n"); cs_close(&handle); } }
static void test() { #define SYSZ_CODE "\xed\x00\x00\x00\x00\x1a\x5a\x0f\x1f\xff\xc2\x09\x80\x00\x00\x00\x07\xf7\xeb\x2a\xff\xff\x7f\x57\xe3\x01\xff\xff\x7f\x57\xeb\x00\xf0\x00\x00\x24\xb2\x4f\x00\x78\xec\x18\x00\x00\xc1\x7f" struct platform platforms[] = { { CS_ARCH_SYSZ, CS_MODE_BIG_ENDIAN, (unsigned char*)SYSZ_CODE, sizeof(SYSZ_CODE) - 1, "SystemZ", }, }; uint64_t address = 0x1000; cs_insn *insn; int i; size_t count; for (i = 0; i < sizeof(platforms)/sizeof(platforms[0]); i++) { cs_err err = cs_open(platforms[i].arch, platforms[i].mode, &handle); if (err) { printf("Failed on cs_open() with error returned: %u\n", err); continue; } cs_option(handle, CS_OPT_DETAIL, CS_OPT_ON); count = cs_disasm(handle, platforms[i].code, platforms[i].size, address, 0, &insn); if (count) { size_t j; printf("****************\n"); printf("Platform: %s\n", platforms[i].comment); print_string_hex("Code:", platforms[i].code, platforms[i].size); printf("Disasm:\n"); for (j = 0; j < count; j++) { printf("0x%"PRIx64":\t%s\t%s\n", insn[j].address, insn[j].mnemonic, insn[j].op_str); print_insn_detail(&insn[j]); } printf("0x%"PRIx64":\n", insn[j-1].address + insn[j-1].size); // free memory allocated by cs_disasm() cs_free(insn, count); } else { printf("****************\n"); printf("Platform: %s\n", platforms[i].comment); print_string_hex("Code:", platforms[i].code, platforms[i].size); printf("ERROR: Failed to disasm given code!\n"); } printf("\n"); cs_close(&handle); } }
static void test() { //#define ARM64_CODE "\xe1\x0b\x40\xb9" // ldr w1, [sp, #0x8] //#define ARM64_CODE "\x21\x7c\x00\x53" // lsr w1, w1, #0x0 //#define ARM64_CODE "\x21\x7c\x02\x9b" //#define ARM64_CODE "\x20\x04\x81\xda" // csneg x0, x1, x1, eq | cneg x0, x1, ne //#define ARM64_CODE "\x20\x08\x02\x8b" // add x0, x1, x2, lsl #2 //#define ARM64_CODE "\x20\xcc\x20\x8b" //#define ARM64_CODE "\xe2\x8f\x40\xa9" // ldp x2, x3, [sp, #8] //#define ARM64_CODE "\x20\x40\x60\x1e" // fmov d0, d1 //#define ARM64_CODE "\x20\x7c\x7d\x93" // sbfiz x0, x1, #3, #32 //#define ARM64_CODE "\x20\x88\x43\xb3" // bfxil x0, x1, #3, #32 //#define ARM64_CODE "\x01\x71\x08\xd5" // sys #0, c7, c1, #0, x1 //#define ARM64_CODE "\x00\x71\x28\xd5" // sysl x0, #0, c7, c1, #0 //#define ARM64_CODE "\x20\xf4\x18\x9e" // fcvtzs x0, s1, #3 //#define ARM64_CODE "\x20\x74\x0b\xd5" // dc zva, x0: FIXME: handle as "sys" insn //#define ARM64_CODE "\x00\x90\x24\x1e" // fmov s0, ##10.00000000 //#define ARM64_CODE "\xe1\x0b\x40\xb9" // ldr w1, [sp, #0x8] //#define ARM64_CODE "\x20\x78\x62\xf8" // ldr x0, [x1, x2, lsl #3] //#define ARM64_CODE "\x41\x14\x44\xb3" // bfm x1, x2, #4, #5 //#define ARM64_CODE "\x80\x23\x29\xd5" // sysl x0, #1, c2, c3, #4 //#define ARM64_CODE "\x20\x00\x24\x1e" // fcvtas w0, s1 //#define ARM64_CODE "\x41\x04\x40\xd2" // eor x1, x2, #0x3 //#define ARM64_CODE "\x9f\x33\x03\xd5" // dsb osh //#define ARM64_CODE "\x41\x10\x23\x8a" // bic x1, x2, x3, lsl #4 //#define ARM64_CODE "\x16\x41\x3c\xd5" // mrs x22, sp_el1 //#define ARM64_CODE "\x41\x1c\x63\x0e" // bic v1.8b, v2.8b, v3.8b //#define ARM64_CODE "\x41\xd4\xe3\x6e" // fabd v1.2d, v2.2d, v3.2d //#define ARM64_CODE "\x20\x8c\x62\x2e" // cmeq v0.4h, v1.4h, v2.4h //#define ARM64_CODE "\x20\x98\x20\x4e" // cmeq v0.16b, v1.16b, #0 //#define ARM64_CODE "\x20\x2c\x05\x4e" // smov x0, v1.b[2] //#define ARM64_CODE "\x21\xe4\x00\x2f" // movi d1, #0xff //#define ARM64_CODE "\x60\x78\x08\xd5" // at s1e0w, x0 // FIXME: same problem with dc ZVA //#define ARM64_CODE "\x20\x00\xa0\xf2" // movk x0, #1, lsl #16 //#define ARM64_CODE "\x20\x08\x00\xb1" // adds x0, x1, #0x2 //#define ARM64_CODE "\x41\x04\x00\x0f" // movi v1.2s, #0x2 //#define ARM64_CODE "\x06\x00\x00\x14" // b 0x44 //#define ARM64_CODE "\x00\x90\x24\x1e" // fmov s0, ##10.00000000 //#define ARM64_CODE "\x5f\x3f\x03\xd5" // clrex //#define ARM64_CODE "\x5f\x3e\x03\xd5" // clrex #14 //#define ARM64_CODE "\x20\x00\x02\xab" // adds x0, x1, x2 (alias of adds x0, x1, x2, lsl #0) //#define ARM64_CODE "\x20\xf4\x18\x9e" // fcvtzs x0, s1, #3 //#define ARM64_CODE "\x20\xfc\x02\x9b" // mneg x0, x1, x2 //#define ARM64_CODE "\xd0\xb6\x1e\xd5" // msr s3_6_c11_c6_6, x16 //#define ARM64_CODE "\x21\x7c\x02\x9b\x21\x7c\x00\x53\x00\x40\x21\x4b\xe1\x0b\x40\xb9\x20\x04\x81\xda\x20\x08\x02\x8b" //#define ARM64_CODE "\x09\x00\x38\xd5" // DBarrier //#define ARM64_CODE "\x20\xe4\x3d\x0f\xa2\x00\xae\x9e" //#define ARM64_CODE "\x9f\x37\x03\xd5\xbf\x33\x03\xd5\xdf\x3f\x03\xd5" // DBarrier //#define ARM64_CODE "\x10\x5b\xe8\x3c" //#define ARM64_CODE "\x00\x18\xa0\x5f\xa2\x00\xae\x9e" #define ARM64_CODE "\x09\x00\x38\xd5\xbf\x40\x00\xd5\x0c\x05\x13\xd5\x20\x50\x02\x0e\x20\xe4\x3d\x0f\x00\x18\xa0\x5f\xa2\x00\xae\x9e\x9f\x37\x03\xd5\xbf\x33\x03\xd5\xdf\x3f\x03\xd5\x21\x7c\x02\x9b\x21\x7c\x00\x53\x00\x40\x21\x4b\xe1\x0b\x40\xb9\x20\x04\x81\xda\x20\x08\x02\x8b\x10\x5b\xe8\x3c" struct platform platforms[] = { { CS_ARCH_ARM64, CS_MODE_ARM, (unsigned char *)ARM64_CODE, sizeof(ARM64_CODE) - 1, "ARM-64" }, }; uint64_t address = 0x2c; cs_insn *insn; int i; size_t count; for (i = 0; i < sizeof(platforms)/sizeof(platforms[0]); i++) { cs_err err = cs_open(platforms[i].arch, platforms[i].mode, &handle); if (err) { printf("Failed on cs_open() with error returned: %u\n", err); continue; } cs_option(handle, CS_OPT_DETAIL, CS_OPT_ON); count = cs_disasm(handle, platforms[i].code, platforms[i].size, address, 0, &insn); if (count) { size_t j; printf("****************\n"); printf("Platform: %s\n", platforms[i].comment); print_string_hex("Code: ", platforms[i].code, platforms[i].size); printf("Disasm:\n"); for (j = 0; j < count; j++) { printf("0x%"PRIx64":\t%s\t%s\n", insn[j].address, insn[j].mnemonic, insn[j].op_str); print_insn_detail(&insn[j]); } printf("0x%"PRIx64":\n", insn[j-1].address + insn[j-1].size); // free memory allocated by cs_disasm() cs_free(insn, count); } else { printf("****************\n"); printf("Platform: %s\n", platforms[i].comment); print_string_hex("Code: ", platforms[i].code, platforms[i].size); printf("ERROR: Failed to disasm given code!\n"); } printf("\n"); cs_close(&handle); } }
static void test() { //#define ARM_CODE "\x04\xe0\x2d\xe5" // str lr, [sp, #-0x4]! //#define ARM_CODE "\xe0\x83\x22\xe5" // str r8, [r2, #-0x3e0]! //#define ARM_CODE "\xf1\x02\x03\x0e" // mcreq p0x2, #0x0, r0, c0x3, c0x1, #0x7 //#define ARM_CODE "\x00\x00\xa0\xe3" // mov r0, #0x0 //#define ARM_CODE "\x02\x30\xc1\xe7" // strb r3, [r1, r2] //#define ARM_CODE "\x00\x00\x53\xe3" // cmp r3, #0x0 //#define ARM_CODE "\x02\x00\xa1\xe2" // adc r0, r1, r2 //#define ARM_CODE "\x21\x01\xa0\xe0" // adc r0, r0, r1, lsr #2 //#define ARM_CODE "\x21\x01\xb0\xe0" // adcs r0, r0, r1, lsr #2 //#define ARM_CODE "\x32\x03\xa1\xe0" // adc r0, r1, r2, lsr r3 //#define ARM_CODE "\x22\x01\xa1\xe0" // adc r0, r1, r2, lsr #2 //#define ARM_CODE "\x65\x61\x4f\x50" // subpl r6, pc, r5, ror #2 //#define ARM_CODE "\x30\x30\x53\xe5" // ldrb r3, [r3, #-0x30] //#define ARM_CODE "\xb6\x10\xdf\xe1" // ldrh r1, [pc, #0x6] //#define ARM_CODE "\x02\x00\x9f\xef" // svc #0x9f0002 //#define ARM_CODE "\x00\xc0\x27\xea" // b 0x9F0002: FIXME: disasm as "b #0x9f0000" //#define ARM_CODE "\x12\x13\xa0\xe1" // lsl r1, r2, r3 //#define ARM_CODE "\x82\x11\xa0\xe1" // lsl r1, r2, #0x3 //#define ARM_CODE "\x00\xc0\xa0\xe1" // mov ip, r0 //#define ARM_CODE "\x02\x00\x12\xe3" // tst r2, #2 //#define ARM_CODE "\x51\x12\xa0\xe1" // asr r1, r2 //#define ARM_CODE "\x72\x10\xef\xe6" // uxtb r1, r2 //#define ARM_CODE "\xe0\x0a\xb7\xee" // vcvt.f64.f32 d0, s1 //#define ARM_CODE "\x9f\x0f\x91\xe1" // ldrex r0, [r1] //#define ARM_CODE "\x0f\x06\x20\xf4" // vld1.8 {d0, d1, d2}, [r0] //#define ARM_CODE "\x72\x00\xa1\xe6" // sxtab r0, r1, r2 //#define ARM_CODE "\x50\x06\x84\xf2" // vmov.i32 q0, #0x40000000 //#define ARM_CODE "\x73\xe0\xb8\xee" // mrc p0, #5, lr, c8, c3, #3 //#define ARM_CODE "\x12\x02\x81\xe6" // pkhbt r0, r1, r2, lsl #0x4 //#define ARM_CODE "\x12\x00\xa0\xe6" // ssat r0, #0x1, r2 //#define ARM_CODE "\x03\x60\x2d\xe9" // push {r0, r1, sp, lr} //#define ARM_CODE "\x8f\x40\x60\xf4" // vld4.32 {d20, d21, d22, d23}, [r0] //#define ARM_CODE "\xd0\x00\xc2\xe1" // ldrd r0, r1, [r2] //#define ARM_CODE "\x08\xf0\xd0\xf5" // pld [r0, #0x8] //#define ARM_CODE "\x10\x8b\xbc\xec" // ldc p11, c8, [r12], #64 //#define ARM_CODE "\xd4\x30\xd2\xe1" // ldrsb r3, [r2, #0x4] //#define ARM_CODE "\x11\x0f\xbe\xf2" // vcvt.s32.f32 d0, d1, #2 //#define ARM_CODE "\x01\x01\x70\xe1" // cmn r0, r1, lsl #2 //#define ARM_CODE "\x06\x00\x91\xe2" // adds r0, r1, #6 //#define ARM_CODE "\x5b\xf0\x7f\xf5" // dmb ish //#define ARM_CODE "\xf7\xff\xff\xfe" //#define ARM_CODE "\x00\x20\xbd\xe8" // ldm sp!, {sp} //#define ARM_CODE "\x00\xa0\xbd\xe8" // pop {sp, pc} //#define ARM_CODE "\x90\x04\x0E\x00" // muleq lr, r0, r4 //#define ARM_CODE "\x90\x24\x0E\x00" // muleq lr, r0, r4 //#define ARM_CODE "\xb6\x10\x5f\xe1" // ldrh r1, [pc, #-6] #define ARM_CODE "\xED\xFF\xFF\xEB\x04\xe0\x2d\xe5\x00\x00\x00\x00\xe0\x83\x22\xe5\xf1\x02\x03\x0e\x00\x00\xa0\xe3\x02\x30\xc1\xe7\x00\x00\x53\xe3\x00\x02\x01\xf1\x05\x40\xd0\xe8\xf4\x80\x00\x00" //#define ARM_CODE2 "\xf0\x24" //#define ARM_CODE2 "\x83\xb0" #define ARM_CODE2 "\xd1\xe8\x00\xf0\xf0\x24\x04\x07\x1f\x3c\xf2\xc0\x00\x00\x4f\xf0\x00\x01\x46\x6c" //#define THUMB_CODE "\x70\x47" // bl 0x26 //#define THUMB_CODE "\x07\xdd" // ble 0x1c //#define THUMB_CODE "\x00\x47" // bx r0 //#define THUMB_CODE "\x01\x47" // bx r0 //#define THUMB_CODE "\x02\x47" // bx r0 //#define THUMB_CODE "\x0a\xbf" // itet eq #define THUMB_CODE "\x70\x47\xeb\x46\x83\xb0\xc9\x68\x1f\xb1\x30\xbf\xaf\xf3\x20\x84" #define THUMB_CODE2 "\x4f\xf0\x00\x01\xbd\xe8\x00\x88\xd1\xe8\x00\xf0\x18\xbf\xad\xbf\xf3\xff\x0b\x0c\x86\xf3\x00\x89\x80\xf3\x00\x8c\x4f\xfa\x99\xf6\xd0\xff\xa2\x01" #define THUMB_MCLASS "\xef\xf3\x02\x80" #define ARMV8 "\xe0\x3b\xb2\xee\x42\x00\x01\xe1\x51\xf0\x7f\xf5" struct platform platforms[] = { { CS_ARCH_ARM, CS_MODE_ARM, (unsigned char *)ARM_CODE, sizeof(ARM_CODE) - 1, "ARM" }, { CS_ARCH_ARM, CS_MODE_THUMB, (unsigned char *)THUMB_CODE, sizeof(THUMB_CODE) - 1, "Thumb" }, { CS_ARCH_ARM, CS_MODE_THUMB, (unsigned char *)ARM_CODE2, sizeof(ARM_CODE2) - 1, "Thumb-mixed" }, { CS_ARCH_ARM, CS_MODE_THUMB, (unsigned char *)THUMB_CODE2, sizeof(THUMB_CODE2) - 1, "Thumb-2 & register named with numbers", CS_OPT_SYNTAX_NOREGNAME }, { CS_ARCH_ARM, (cs_mode)(CS_MODE_THUMB + CS_MODE_MCLASS), (unsigned char*)THUMB_MCLASS, sizeof(THUMB_MCLASS) - 1, "Thumb-MClass" }, { CS_ARCH_ARM, (cs_mode)(CS_MODE_ARM + CS_MODE_V8), (unsigned char*)ARMV8, sizeof(ARMV8) - 1, "Arm-V8" }, }; uint64_t address = 0x1000; cs_insn *insn; int i; size_t count; for (i = 0; i < sizeof(platforms)/sizeof(platforms[0]); i++) { cs_err err = cs_open(platforms[i].arch, platforms[i].mode, &handle); if (err) { printf("Failed on cs_open() with error returned: %u\n", err); continue; } cs_option(handle, CS_OPT_DETAIL, CS_OPT_ON); if (platforms[i].syntax) cs_option(handle, CS_OPT_SYNTAX, platforms[i].syntax); count = cs_disasm(handle, platforms[i].code, platforms[i].size, address, 0, &insn); if (count) { size_t j; printf("****************\n"); printf("Platform: %s\n", platforms[i].comment); print_string_hex("Code:", platforms[i].code, platforms[i].size); printf("Disasm:\n"); for (j = 0; j < count; j++) { printf("0x%" PRIx64 ":\t%s\t%s\n", insn[j].address, insn[j].mnemonic, insn[j].op_str); print_insn_detail(&insn[j]); } printf("0x%" PRIx64 ":\n", insn[j-1].address + insn[j-1].size); // free memory allocated by cs_disasm() cs_free(insn, count); } else { printf("****************\n"); printf("Platform: %s\n", platforms[i].comment); print_string_hex("Code:", platforms[i].code, platforms[i].size); printf("ERROR: Failed to disasm given code!\n"); } printf("\n"); cs_close(&handle); } }
static void test() { //#define MIPS_CODE "\x8f\xa2\x00\x00" //#define MIPS_CODE "\x00\x00\xa7\xac\x10\x00\xa2\x8f" //#define MIPS_CODE "\x21\x30\xe6\x70" // clo $6, $7 //#define MIPS_CODE "\x00\x00\x00\x00" // nop //#define MIPS_CODE "\xc6\x23\xe9\xe4" // swc1 $f9, 0x23c6($7) //#define MIPS_CODE "\x21\x38\x00\x01" // move $7, $8 #define MIPS_CODE "\x0C\x10\x00\x97\x00\x00\x00\x00\x24\x02\x00\x0c\x8f\xa2\x00\x00\x34\x21\x34\x56" //#define MIPS_CODE "\x04\x11\x00\x01" // bal 0x8 #define MIPS_CODE2 "\x56\x34\x21\x34\xc2\x17\x01\x00" struct platform platforms[] = { { CS_ARCH_MIPS, (cs_mode)(CS_MODE_32 + CS_MODE_BIG_ENDIAN), (unsigned char *)MIPS_CODE, sizeof(MIPS_CODE) - 1, "MIPS-32 (Big-endian)" }, { CS_ARCH_MIPS, (cs_mode)(CS_MODE_64 + CS_MODE_LITTLE_ENDIAN), (unsigned char *)MIPS_CODE2, sizeof(MIPS_CODE2) - 1, "MIPS-64-EL (Little-endian)" }, }; uint64_t address = 0x1000; cs_insn *insn; int i; size_t count; for (i = 0; i < sizeof(platforms)/sizeof(platforms[0]); i++) { cs_err err = cs_open(platforms[i].arch, platforms[i].mode, &handle); if (err) { printf("Failed on cs_open() with error returned: %u\n", err); continue; } cs_option(handle, CS_OPT_DETAIL, CS_OPT_ON); count = cs_disasm_ex(handle, platforms[i].code, platforms[i].size, address, 0, &insn); if (count) { size_t j; printf("****************\n"); printf("Platform: %s\n", platforms[i].comment); print_string_hex("Code:", platforms[i].code, platforms[i].size); printf("Disasm:\n"); for (j = 0; j < count; j++) { printf("0x%"PRIx64":\t%s\t%s\n", insn[j].address, insn[j].mnemonic, insn[j].op_str); print_insn_detail(&insn[j]); } printf("0x%"PRIx64":\n", insn[j-1].address + insn[j-1].size); // free memory allocated by cs_disasm_ex() cs_free(insn, count); } else { printf("****************\n"); printf("Platform: %s\n", platforms[i].comment); print_string_hex("Code:", platforms[i].code, platforms[i].size); printf("ERROR: Failed to disasm given code!\n"); } printf("\n"); cs_close(&handle); } }
static void test() { #define SPARC_CODE "\x80\xa0\x40\x02\x85\xc2\x60\x08\x85\xe8\x20\x01\x81\xe8\x00\x00\x90\x10\x20\x01\xd5\xf6\x10\x16\x21\x00\x00\x0a\x86\x00\x40\x02\x01\x00\x00\x00\x12\xbf\xff\xff\x10\xbf\xff\xff\xa0\x02\x00\x09\x0d\xbf\xff\xff\xd4\x20\x60\x00\xd4\x4e\x00\x16\x2a\xc2\x80\x03" #define SPARCV9_CODE "\x81\xa8\x0a\x24\x89\xa0\x10\x20\x89\xa0\x1a\x60\x89\xa0\x00\xe0" struct platform platforms[] = { { CS_ARCH_SPARC, CS_MODE_BIG_ENDIAN, (unsigned char*)SPARC_CODE, sizeof(SPARC_CODE) - 1, "Sparc", }, { CS_ARCH_SPARC, (cs_mode)(CS_MODE_BIG_ENDIAN + CS_MODE_V9), (unsigned char*)SPARCV9_CODE, sizeof(SPARCV9_CODE) - 1, "SparcV9" }, }; uint64_t address = 0x1000; cs_insn *insn; int i; size_t count; for (i = 0; i < sizeof(platforms)/sizeof(platforms[0]); i++) { cs_err err = cs_open(platforms[i].arch, platforms[i].mode, &handle); if (err) { printf("Failed on cs_open() with error returned: %u\n", err); continue; } cs_option(handle, CS_OPT_DETAIL, CS_OPT_ON); count = cs_disasm(handle, platforms[i].code, platforms[i].size, address, 0, &insn); if (count) { size_t j; printf("****************\n"); printf("Platform: %s\n", platforms[i].comment); print_string_hex("Code:", platforms[i].code, platforms[i].size); printf("Disasm:\n"); for (j = 0; j < count; j++) { printf("0x%"PRIx64":\t%s\t%s\n", insn[j].address, insn[j].mnemonic, insn[j].op_str); print_insn_detail(&insn[j]); } printf("0x%"PRIx64":\n", insn[j-1].address + insn[j-1].size); // free memory allocated by cs_disasm() cs_free(insn, count); } else { printf("****************\n"); printf("Platform: %s\n", platforms[i].comment); print_string_hex("Code:", platforms[i].code, platforms[i].size); printf("ERROR: Failed to disasm given code!\n"); } printf("\n"); cs_close(&handle); } }
static void test() { #define M6800_CODE \ "\x01\x09\x36\x64\x7f\x74\x10\x00\x90\x10\xA4\x10\xb6\x10\x00\x39" #define M6801_CODE \ "\x04\x05\x3c\x3d\x38\x93\x10\xec\x10\xed\x10\x39" #define M6805_CODE \ "\x04\x7f\x00\x17\x22\x28\x00\x2e\x00\x40\x42\x5a\x70\x8e\x97\x9c" \ "\xa0\x15\xad\x00\xc3\x10\x00\xda\x12\x34\xe5\x7f\xfe" #define M6808_CODE \ "\x31\x22\x00\x35\x22\x45\x10\x00\x4b\x00\x51\x10\x52\x5e\x22\x62" \ "\x65\x12\x34\x72\x84\x85\x86\x87\x8a\x8b\x8c\x94\x95\xa7\x10\xaf\x10" \ "\x9e\x60\x7f\x9e\x6b\x7f\x00\x9e\xd6\x10\x00\x9e\xe6\x7f" #define HCS08_CODE \ "\x32\x10\x00\x9e\xae\x9e\xce\x7f\x9e\xbe\x10\x00\x9e\xfe\x7f" \ "\x3e\x10\x00\x9e\xf3\x7f\x96\x10\x00\x9e\xff\x7f\x82" #define M6811_CODE \ "\x02\x03\x12\x7f\x10\x00\x13\x99\x08\x00\x14\x7f\x02\x15\x7f\x01" \ "\x1e\x7f\x20\x00\x8f\xcf" \ "\x18\x08\x18\x30\x18\x3c\x18\x67\x18\x8c\x10\x00\x18\x8f" \ "\x18\xce\x10\x00\x18\xff\x10\x00" \ "\x1a\xa3\x7f\x1a\xac\x1a\xee\x7f\x1a\xef\x7f\xcd\xac\x7f" #define CPU12_CODE \ "\x00\x04\x01\x00\x0c\x00\x80\x0e\x00\x80\x00\x11\x1e\x10\x00\x80\x00" \ "\x3b\x4a\x10\x00\x04\x4b\x01\x04\x4f\x7f\x80\x00\x8f\x10\x00\xb7\x52" \ "\xb7\xb1\xa6\x67\xa6\xfe\xa6\xf7\x18\x02\xe2\x30\x39\xe2\x10\x00" \ "\x18\x0c\x30\x39\x10\x00\x18\x11\x18\x12\x10\x00\x18\x19\x00\x18\x1e\x00" \ "\x18\x3e\x18\x3f\x00" #define HD6301_CODE \ "\x6b\x10\x00\x71\x10\x00\x72\x10\x10\x39" #define M6809_CODE \ "\x06\x10\x19\x1a\x55\x1e\x01\x23\xe9\x31\x06\x34\x55\xa6\x81" \ "\xa7\x89\x7f\xff\xa6\x9d\x10\x00\xa7\x91\xa6\x9f\x10\x00" \ "\x11\xac\x99\x10\x00\x39" \ \ "\xA6\x07\xA6\x27\xA6\x47\xA6\x67\xA6\x0F\xA6\x10" \ "\xA6\x80\xA6\x81\xA6\x82\xA6\x83\xA6\x84\xA6\x85\xA6\x86" \ "\xA6\x88\x7F\xA6\x88\x80\xA6\x89\x7F\xFF\xA6\x89\x80\x00" \ "\xA6\x8B\xA6\x8C\x10\xA6\x8D\x10\x00" \ \ "\xA6\x91\xA6\x93\xA6\x94\xA6\x95\xA6\x96" \ "\xA6\x98\x7F\xA6\x98\x80\xA6\x99\x7F\xFF\xA6\x99\x80\x00" \ "\xA6\x9B\xA6\x9C\x10\xA6\x9D\x10\x00\xA6\x9F\x10\x00" #define HD6309_CODE \ "\x01\x10\x10\x62\x10\x10\x7b\x10\x10\x00\xcd\x49\x96\x02\xd2" \ "\x10\x30\x23\x10\x38\x10\x3b\x10\x53\x10\x5d" \ "\x11\x30\x43\x10\x11\x37\x25\x10\x11\x38\x12\x11\x39\x23\x11\x3b\x34" \ "\x11\x8e\x10\x00\x11\xaf\x10\x11\xab\x10\x11\xf6\x80\x00" struct platform platforms[] = { { CS_ARCH_M680X, (cs_mode)(CS_MODE_M680X_6301), (unsigned char *)HD6301_CODE, sizeof(HD6301_CODE) - 1, "M680X_HD6301", }, { CS_ARCH_M680X, (cs_mode)(CS_MODE_M680X_6309), (unsigned char *)HD6309_CODE, sizeof(HD6309_CODE) - 1, "M680X_HD6309", }, { CS_ARCH_M680X, (cs_mode)(CS_MODE_M680X_6800), (unsigned char *)M6800_CODE, sizeof(M6800_CODE) - 1, "M680X_M6800", }, { CS_ARCH_M680X, (cs_mode)(CS_MODE_M680X_6801), (unsigned char *)M6801_CODE, sizeof(M6801_CODE) - 1, "M680X_M6801", }, { CS_ARCH_M680X, (cs_mode)(CS_MODE_M680X_6805), (unsigned char *)M6805_CODE, sizeof(M6805_CODE) - 1, "M680X_M68HC05", }, { CS_ARCH_M680X, (cs_mode)(CS_MODE_M680X_6808), (unsigned char *)M6808_CODE, sizeof(M6808_CODE) - 1, "M680X_M68HC08", }, { CS_ARCH_M680X, (cs_mode)(CS_MODE_M680X_6809), (unsigned char *)M6809_CODE, sizeof(M6809_CODE) - 1, "M680X_M6809", }, { CS_ARCH_M680X, (cs_mode)(CS_MODE_M680X_6811), (unsigned char *)M6811_CODE, sizeof(M6811_CODE) - 1, "M680X_M68HC11", }, { CS_ARCH_M680X, (cs_mode)(CS_MODE_M680X_CPU12), (unsigned char *)CPU12_CODE, sizeof(CPU12_CODE) - 1, "M680X_CPU12", }, { CS_ARCH_M680X, (cs_mode)(CS_MODE_M680X_HCS08), (unsigned char *)HCS08_CODE, sizeof(HCS08_CODE) - 1, "M680X_HCS08", }, }; uint64_t address = 0x1000; csh handle; cs_insn *insn; int i; size_t count; const char *nine_spaces = " "; if (!consistency_checks()) abort(); for (i = 0; i < sizeof(platforms) / sizeof(platforms[0]); i++) { cs_err err = cs_open(platforms[i].arch, platforms[i].mode, &handle); if (err) { printf("Failed on cs_open() with error returned: %u\n", err); abort(); } #ifdef WITH_DETAILS cs_option(handle, CS_OPT_DETAIL, CS_OPT_ON); #endif count = cs_disasm(handle, platforms[i].code, platforms[i].size, address, 0, &insn); if (count) { size_t j; printf("********************\n"); printf("Platform: %s\n", platforms[i].comment); print_string_hex("Code: ", platforms[i].code, platforms[i].size); printf("Disasm:\n"); for (j = 0; j < count; j++) { int slen; printf("0x%04x: ", (uint16_t)insn[j].address); print_string_hex_short(insn[j].bytes, insn[j].size); printf("%.*s", 1 + ((5 - insn[j].size) * 2), nine_spaces); printf("%s", insn[j].mnemonic); slen = (int)strlen(insn[j].mnemonic); printf("%.*s", 1 + (5 - slen), nine_spaces); printf("%s\n", insn[j].op_str); #ifdef WITH_DETAILS print_insn_detail(handle, &insn[j]); #endif } // free memory allocated by cs_disasm() cs_free(insn, count); } else { printf("********************\n"); printf("Platform: %s\n", platforms[i].comment); print_string_hex("Code:", platforms[i].code, platforms[i].size); printf("ERROR: Failed to disasm given code!\n"); abort(); } cs_close(&handle); } }
static void test_invalids() { struct invalid_instructions invalids[] = {{ CS_ARCH_ARM, CS_MODE_THUMB, "Thumb", 1, {{ (unsigned char *)"\xbd\xe8\x1e\xff", 4, "invalid thumb2 pop because sp used and because both pc and lr are " "present at the same time" }}, }}; struct invalid_instructions * invalid = NULL; uint64_t address = 0x1000; cs_insn *insn; int i; int j; size_t count; printf("\nShould be invalid\n" "-----------------\n"); for (i = 0; i < sizeof(invalids)/sizeof(invalids[0]); i++) { cs_err err; invalid = invalids + i; err = cs_open(invalid->arch, invalid->mode, &handle); if (err) { printf("Failed on cs_open() with error returned: %u\n", err); continue; } cs_option(handle, CS_OPT_DETAIL, CS_OPT_ON); cs_option(handle, CS_OPT_SYNTAX, CS_OPT_SYNTAX_NOREGNAME); for (j = 0; j < invalid->num_invalid_codes; ++j) { struct invalid_code *invalid_code = NULL; char *hex_str = NULL; invalid_code = invalid->invalid_codes + j; hex_str = hex_string(invalid_code->code, invalid_code->size); printf("%s %s: %s\n", invalid->platform_comment, hex_str, invalid_code->comment); free(hex_str); count = cs_disasm(handle, invalid_code->code, invalid_code->size, address, 0, &insn ); if (count) { size_t k; printf(" ERROR:\n"); for (k = 0; k < count; k++) { printf(" 0x%"PRIx64":\t%s\t%s\n", insn[k].address, insn[k].mnemonic, insn[k].op_str); print_insn_detail(&insn[k]); } cs_free(insn, count); } else { printf(" SUCCESS: invalid\n"); } } cs_close(&handle); } }