Magic-Mirror/radare2
1
0
Fork 0
mirror of https://github.com/radareorg/radare2.git synced 2025-02-21 23:01:03 +00:00
Code Issues Actions 6 Packages Projects Releases Wiki Activity

Fix random code style issues

Browse Source
This commit is contained in:
Marc 2017-07-12 17:07:47 +02:00
parent 066e85554e
commit 80d4b44b2e
14 changed files with 652 additions and 523 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
binr/rafind2/rafind2.c
View File

@ -223,7 +223,7 @@ int main(int argc, char **argv) {
mode = R_SEARCH_KEYWORD;
hexstr = 0;
widestr = 1;
r_list_append(keywords, optarg);
r_list_append (keywords, optarg);
break;
case 'b':
bsize = r_num_math (NULL, optarg);

2
libr/anal/sign.c
View File

@ -889,7 +889,7 @@ static int addSearchKwCB(RSignItem *it, void *user) {
}
it2 = r_sign_item_dup (it);
r_list_append(ss->items, it2);
r_list_append (ss->items, it2);
// TODO(nibble): change arg data in r_search_keyword_new to void*
kw = r_search_keyword_new (bytes->bytes, bytes->size, bytes->mask, bytes->size, (const char *) it2);

480
libr/asm/arch/arm/winedbg/be_arm.c
View File

@ -72,9 +72,11 @@ static ut32 arm_disasm_branch(struct winedbg_arm_insn *arminsn, ut32 inst) {
short link = (inst >> 24) & 0x01;
int offset = (inst << 2) & 0x03ffffff;
if (offset & 0x02000000) offset |= 0xfc000000;
if (offset & 0x02000000){
offset |= 0xfc000000;
}
offset += 8;
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "b%s%s 0x%"PFMT64x, link ? "l" : "", get_cond(inst), arminsn->pc+offset);
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "b%s%s 0x%"PFMT64x, link ? "l" : "", get_cond (inst), arminsn->pc+offset);
arminsn->jmp = arminsn->pc+offset;
arminsn->fail = arminsn->pc+4;
@ -85,14 +87,16 @@ static ut32 arm_disasm_mul(struct winedbg_arm_insn *arminsn, ut32 inst) {
short accu = (inst >> 21) & 0x01;
short condcodes = (inst >> 20) & 0x01;
if (accu)
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "mla%s%s %s, %s, %s, %s", get_cond(inst), condcodes ? "s" : "",
tbl_regs[get_nibble(inst, 4)], tbl_regs[get_nibble(inst, 0)],
tbl_regs[get_nibble(inst, 2)], tbl_regs[get_nibble(inst, 3)]);
else
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "mul%s%s %s, %s, %s", get_cond(inst), condcodes ? "s" : "",
tbl_regs[get_nibble(inst, 4)], tbl_regs[get_nibble(inst, 0)],
tbl_regs[get_nibble(inst, 2)]);
if (accu) {
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "mla%s%s %s, %s, %s, %s", get_cond (inst), condcodes ? "s" : "",
tbl_regs[get_nibble (inst, 4)], tbl_regs[get_nibble (inst, 0)],
tbl_regs[get_nibble (inst, 2)], tbl_regs[get_nibble (inst, 3)]);
}
else {
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "mul%s%s %s, %s, %s", get_cond (inst), condcodes ? "s" : "",
tbl_regs[get_nibble (inst, 4)], tbl_regs[get_nibble (inst, 0)],
tbl_regs[get_nibble (inst, 2)]);
}
return 0;
}
@ -101,36 +105,36 @@ static ut32 arm_disasm_longmul(struct winedbg_arm_insn *arminsn, ut32 inst) {
short accu = (inst >> 21) & 0x01;
short condcodes = (inst >> 20) & 0x01;
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "%s%s%s%s %s, %s, %s, %s", sign ? "s" : "u", accu ? "mlal" : "mull",
get_cond(inst), condcodes ? "s" : "",
tbl_regs[get_nibble(inst, 3)], tbl_regs[get_nibble(inst, 4)],
tbl_regs[get_nibble(inst, 0)], tbl_regs[get_nibble(inst, 2)]);
return 0;
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "%s%s%s%s %s, %s, %s, %s", sign ? "s" : "u", accu ? "mlal" : "mull",
get_cond (inst), condcodes ? "s" : "",
tbl_regs[get_nibble (inst, 3)], tbl_regs[get_nibble (inst, 4)],
tbl_regs[get_nibble (inst, 0)], tbl_regs[get_nibble (inst, 2)]);
return 0;
}
static ut32 arm_disasm_swp(struct winedbg_arm_insn *arminsn, ut32 inst) {
short byte = (inst >> 22) & 0x01;
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "swp%s%s %s, %s, [%s]", get_cond(inst), byte ? "b" : "",
tbl_regs[get_nibble(inst, 3)], tbl_regs[get_nibble(inst, 0)],
tbl_regs[get_nibble(inst, 4)]);
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "swp%s%s %s, %s, [%s]", get_cond (inst), byte ? "b" : "",
tbl_regs[get_nibble (inst, 3)], tbl_regs[get_nibble (inst, 0)],
tbl_regs[get_nibble (inst, 4)]);
return 0;
}
static ut32 arm_disasm_branchreg(struct winedbg_arm_insn *arminsn, ut32 inst) {
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "b%s %s", get_cond(inst), tbl_regs[get_nibble(inst, 0)]);
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "b%s %s", get_cond (inst), tbl_regs[get_nibble (inst, 0)]);
return 0;
}
static ut32 arm_disasm_branchxchg(struct winedbg_arm_insn *arminsn, ut32 inst) {
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "bx%s %s", get_cond(inst), tbl_regs[get_nibble(inst, 0)]);
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "bx%s %s", get_cond (inst), tbl_regs[get_nibble (inst, 0)]);
return 0;
}
static ut32 arm_disasm_mrstrans(struct winedbg_arm_insn *arminsn, ut32 inst) {
short src = (inst >> 22) & 0x01;
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "mrs%s %s, %s", get_cond(inst), tbl_regs[get_nibble(inst, 3)],
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "mrs%s %s, %s", get_cond (inst), tbl_regs[get_nibble (inst, 3)],
src ? "spsr" : "cpsr");
return 0;
}
@ -141,26 +145,26 @@ static ut32 arm_disasm_msrtrans(struct winedbg_arm_insn *arminsn, ut32 inst) {
short simple = (inst >> 16) & 0x01;
if (simple || !immediate) {
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "msr%s %s, %s", get_cond(inst), dst ? "spsr" : "cpsr",
tbl_regs[get_nibble(inst, 0)]);
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "msr%s %s, %s", get_cond (inst), dst ? "spsr" : "cpsr",
tbl_regs[get_nibble (inst, 0)]);
return 0;
}
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "msr%s %s, #%u", get_cond(inst), dst ? "spsr" : "cpsr",
ROR32(inst & 0xff, 2 * get_nibble(inst, 2)));
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "msr%s %s, #%u", get_cond (inst), dst ? "spsr" : "cpsr",
ROR32 (inst & 0xff, 2 * get_nibble (inst, 2)));
return 0;
}
static ut32 arm_disasm_wordmov(struct winedbg_arm_insn *arminsn, ut32 inst) {
short top = (inst >> 22) & 0x01;
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "mov%s%s %s, #%u", top ? "t" : "w", get_cond(inst),
tbl_regs[get_nibble(inst, 3)],
(get_nibble(inst, 4) << 12) | (inst & 0x0fff));
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "mov%s%s %s, #%u", top ? "t" : "w", get_cond (inst),
tbl_regs[get_nibble (inst, 3)],
(get_nibble (inst, 4) << 12) | (inst & 0x0fff));
return 0;
}
static ut32 arm_disasm_nop(struct winedbg_arm_insn *arminsn, ut32 inst) {
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "nop%s", get_cond(inst));
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "nop%s", get_cond (inst));
return 0;
}
@ -171,31 +175,42 @@ static ut32 arm_disasm_dataprocessing(struct winedbg_arm_insn *arminsn, ut32 ins
short no_op1 = (opcode & 0x0d) == 0x0d;
short no_dst = (opcode & 0x0c) == 0x08;
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "%s%s%s", tbl_dataops[opcode], condcodes ? "s" : "", get_cond(inst));
if (!no_dst) arminsn->str_asm = r_str_appendf(arminsn->str_asm, " %s, ", tbl_regs[get_nibble(inst, 3)]);
else arminsn->str_asm = r_str_appendf(arminsn->str_asm, " ");
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "%s%s%s", tbl_dataops[opcode], condcodes ? "s" : "", get_cond (inst));
if (!no_dst) {
arminsn->str_asm = r_str_appendf (arminsn->str_asm, " %s, ", tbl_regs[get_nibble (inst, 3)]);
}
else {
arminsn->str_asm = r_str_appendf (arminsn->str_asm, " ");
}
if (no_op1) {
if (immediate)
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "#%u", ROR32(inst & 0xff, 2 * get_nibble(inst, 2)));
else
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "%s", tbl_regs[get_nibble(inst, 0)]);
if (immediate) {
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "#%u", ROR32 (inst & 0xff, 2 * get_nibble (inst, 2)));
}
else {
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "%s", tbl_regs[get_nibble (inst, 0)]);
}
} else {
if (immediate)
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "%s, #%u", tbl_regs[get_nibble(inst, 4)],
ROR32(inst & 0xff, 2 * get_nibble(inst, 2)));
else if (((inst >> 4) & 0xff) == 0x00) /* no shift */
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "%s, %s", tbl_regs[get_nibble(inst, 4)],
tbl_regs[get_nibble(inst, 0)]);
else if (((inst >> 4) & 0x09) == 0x01) /* register shift */
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "%s, %s, %s %s", tbl_regs[get_nibble(inst, 4)],
tbl_regs[get_nibble(inst, 0)],
if (immediate) {
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "%s, #%u", tbl_regs[get_nibble (inst, 4)],
ROR32 (inst & 0xff, 2 * get_nibble (inst, 2)));
}
else if (((inst >> 4) & 0xff) == 0x00) { /* no shift */
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "%s, %s", tbl_regs[get_nibble (inst, 4)],
tbl_regs[get_nibble (inst, 0)]);
}
else if (((inst >> 4) & 0x09) == 0x01) { /* register shift */
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "%s, %s, %s %s", tbl_regs[get_nibble (inst, 4)],
tbl_regs[get_nibble (inst, 0)],
tbl_shifts[(inst >> 5) & 0x03], tbl_regs[(inst >> 8) & 0x0f]);
else if (((inst >> 4) & 0x01) == 0x00) /* immediate shift */
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "%s, %s, %s #%d", tbl_regs[get_nibble(inst, 4)],
tbl_regs[get_nibble(inst, 0)], tbl_shifts[(inst >> 5) & 0x03],
}
else if (((inst >> 4) & 0x01) == 0x00) { /* immediate shift */
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "%s, %s, %s #%d", tbl_regs[get_nibble (inst, 4)],
tbl_regs[get_nibble (inst, 0)], tbl_shifts[(inst >> 5) & 0x03],
(inst >> 7) & 0x1f);
else
}
else {
return inst;
}
}
return 0;
}
@ -209,35 +224,45 @@ static ut32 arm_disasm_singletrans(struct winedbg_arm_insn *arminsn, ut32 inst)
short immediate = !((inst >> 25) & 0x01);
short offset = inst & 0x0fff;
if (!direction) offset *= -1;
if (!direction) {
offset *= -1;
}
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "%s%s%s%s", load ? "ldr" : "str", byte ? "b" : "", writeback ? "t" : "",
get_cond(inst));
arminsn->str_asm = r_str_appendf(arminsn->str_asm, " %s, ", tbl_regs[get_nibble(inst, 3)]);
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "%s%s%s%s", load ? "ldr" : "str", byte ? "b" : "", writeback ? "t" : "",
get_cond (inst));
arminsn->str_asm = r_str_appendf (arminsn->str_asm, " %s, ", tbl_regs[get_nibble (inst, 3)]);
if (indexing) {
if (immediate)
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "[%s, #%d]", tbl_regs[get_nibble(inst, 4)], offset);
else if (((inst >> 4) & 0xff) == 0x00) /* no shift */
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "[%s, %s]", tbl_regs[get_nibble(inst, 4)],
tbl_regs[get_nibble(inst, 0)]);
else if (((inst >> 4) & 0x01) == 0x00) /* immediate shift (there's no register shift) */
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "[%s, %s, %s #%d]", tbl_regs[get_nibble(inst, 4)],
tbl_regs[get_nibble(inst, 0)], tbl_shifts[(inst >> 5) & 0x03],
if (immediate) {
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "[%s, #%d]", tbl_regs[get_nibble (inst, 4)], offset);
}
else if (((inst >> 4) & 0xff) == 0x00) { /* no shift */
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "[%s, %s]", tbl_regs[get_nibble (inst, 4)],
tbl_regs[get_nibble (inst, 0)]);
}
else if (((inst >> 4) & 0x01) == 0x00) {/* immediate shift (there's no register shift) */
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "[%s, %s, %s #%d]", tbl_regs[get_nibble (inst, 4)],
tbl_regs[get_nibble (inst, 0)], tbl_shifts[(inst >> 5) & 0x03],
(inst >> 7) & 0x1f);
else
}
else {
return inst;
}
} else {
if (immediate)
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "[%s], #%d", tbl_regs[get_nibble(inst, 4)], offset);
else if (((inst >> 4) & 0xff) == 0x00) /* no shift */
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "[%s], %s", tbl_regs[get_nibble(inst, 4)],
tbl_regs[get_nibble(inst, 0)]);
else if (((inst >> 4) & 0x01) == 0x00) /* immediate shift (there's no register shift) */
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "[%s], %s, %s #%d", tbl_regs[get_nibble(inst, 4)],
tbl_regs[get_nibble(inst, 0)], tbl_shifts[(inst >> 5) & 0x03],
if (immediate) {
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "[%s], #%d", tbl_regs[get_nibble (inst, 4)], offset);
}
else if (((inst >> 4) & 0xff) == 0x00) { /* no shift */
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "[%s], %s", tbl_regs[get_nibble (inst, 4)],
tbl_regs[get_nibble (inst, 0)]);
}
else if (((inst >> 4) & 0x01) == 0x00) { /* immediate shift (there's no register shift) */
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "[%s], %s, %s #%d", tbl_regs[get_nibble (inst, 4)],
tbl_regs[get_nibble (inst, 0)], tbl_shifts[(inst >> 5) & 0x03],
(inst >> 7) & 0x1f);
else
}
else {
return inst;
}
}
return 0;
}
@ -252,23 +277,29 @@ static ut32 arm_disasm_halfwordtrans(struct winedbg_arm_insn *arminsn, ut32 inst
short indexing = (inst >> 24) & 0x01;
short offset = ((inst >> 4) & 0xf0) + (inst & 0x0f);
if (!direction) offset *= -1;
if (!direction){
offset *= -1;
}
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "%s%s%s%s%s", load ? "ldr" : "str", sign ? "s" : "",
halfword ? "h" : (sign ? "b" : ""), writeback ? "t" : "", get_cond(inst));
arminsn->str_asm = r_str_appendf(arminsn->str_asm, " %s, ", tbl_regs[get_nibble(inst, 3)]);
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "%s%s%s%s%s", load ? "ldr" : "str", sign ? "s" : "",
halfword ? "h" : (sign ? "b" : ""), writeback ? "t" : "", get_cond (inst));
arminsn->str_asm = r_str_appendf (arminsn->str_asm, " %s, ", tbl_regs[get_nibble (inst, 3)]);
if (indexing) {
if (immediate)
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "[%s, #%d]", tbl_regs[get_nibble(inst, 4)], offset);
else
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "[%s, %s]", tbl_regs[get_nibble(inst, 4)],
tbl_regs[get_nibble(inst, 0)]);
if (immediate) {
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "[%s, #%d]", tbl_regs[get_nibble (inst, 4)], offset);
}
else {
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "[%s, %s]", tbl_regs[get_nibble (inst, 4)],
tbl_regs[get_nibble (inst, 0)]);
}
} else {
if (immediate)
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "[%s], #%d", tbl_regs[get_nibble(inst, 4)], offset);
else
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "[%s], %s", tbl_regs[get_nibble(inst, 4)],
tbl_regs[get_nibble(inst, 0)]);
if (immediate) {
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "[%s], #%d", tbl_regs[get_nibble (inst, 4)], offset);
}
else {
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "[%s], %s", tbl_regs[get_nibble (inst, 4)],
tbl_regs[get_nibble (inst, 0)]);
}
}
return 0;
}
@ -281,26 +312,28 @@ static ut32 arm_disasm_blocktrans(struct winedbg_arm_insn *arminsn, ut32 inst) {
short i;
short last=15;
for (i=15;i>=0;i--)
for (i=15;i>=0;i--) {
if ((inst>>i) & 1) {
last = i;
break;
}
}
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "%s%s%s %s%s, {", load ? "ldm" : "stm", tbl_addrmode[addrmode],
get_cond(inst), tbl_regs[get_nibble(inst, 4)], writeback ? "!" : "");
for (i=0;i<=15;i++)
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "%s%s%s %s%s, {", load ? "ldm" : "stm", tbl_addrmode[addrmode],
get_cond (inst), tbl_regs[get_nibble (inst, 4)], writeback ? "!" : "");
for (i=0;i<=15;i++) {
if ((inst>>i) & 1) {
if (i == last) arminsn->str_asm = r_str_appendf(arminsn->str_asm, "%s", tbl_regs[i]);
else arminsn->str_asm = r_str_appendf(arminsn->str_asm, "%s, ", tbl_regs[i]);
if (i == last) arminsn->str_asm = r_str_appendf (arminsn->str_asm, "%s", tbl_regs[i]);
else arminsn->str_asm = r_str_appendf (arminsn->str_asm, "%s, ", tbl_regs[i]);
}
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "}%s", psr ? "^" : "");
}
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "}%s", psr ? "^" : "");
return 0;
}
static ut32 arm_disasm_swi(struct winedbg_arm_insn *arminsn, ut32 inst) {
ut32 comment = inst & 0x00ffffff;
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "swi%s #%d", get_cond(inst), comment);
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "swi%s #%d", get_cond (inst), comment);
return 0;
}
@ -312,8 +345,8 @@ static ut32 arm_disasm_coproctrans(struct winedbg_arm_insn *arminsn, ut32 inst)
ut16 load = (inst >> 20) & 0x01;
ut16 CP_Opc = (inst >> 21) & 0x07;
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "%s%s %u, %u, %s, cr%u, cr%u, {%u}", load ? "mrc" : "mcr",
get_cond(inst), CPnum, CP, tbl_regs[get_nibble(inst, 3)], CRn, CRm, CP_Opc);
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "%s%s %u, %u, %s, cr%u, cr%u, {%u}", load ? "mrc" : "mcr",
get_cond (inst), CPnum, CP, tbl_regs[get_nibble (inst, 3)], CRn, CRm, CP_Opc);
return 0;
}
@ -325,7 +358,7 @@ static ut32 arm_disasm_coprocdataop(struct winedbg_arm_insn *arminsn, ut32 inst)
ut16 CRn = (inst >> 16) & 0x0f;
ut16 CP_Opc = (inst >> 20) & 0x0f;
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "cdp%s %u, %u, cr%u, cr%u, cr%u, {%u}", get_cond(inst),
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "cdp%s %u, %u, cr%u, cr%u, cr%u, {%u}", get_cond (inst),
CPnum, CP, CRd, CRn, CRm, CP_Opc);
return 0;
}
@ -340,14 +373,16 @@ static ut32 arm_disasm_coprocdatatrans(struct winedbg_arm_insn *arminsn, ut32 in
ut16 indexing = (inst >> 24) & 0x01;
short offset = (inst & 0xff) << 2;
if (!direction) offset *= -1;
if (!direction) {
offset *= -1;
}
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "%s%s%s", load ? "ldc" : "stc", translen ? "l" : "", get_cond(inst));
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "%s%s%s", load ? "ldc" : "stc", translen ? "l" : "", get_cond (inst));
if (indexing)
arminsn->str_asm = r_str_appendf(arminsn->str_asm, " %u, cr%u, [%s, #%d]%s", CPnum, CRd, tbl_regs[get_nibble(inst, 4)],
arminsn->str_asm = r_str_appendf (arminsn->str_asm, " %u, cr%u, [%s, #%d]%s", CPnum, CRd, tbl_regs[get_nibble (inst, 4)],
offset, writeback?"!":"");
else
arminsn->str_asm = r_str_appendf(arminsn->str_asm, " %u, cr%u, [%s], #%d", CPnum, CRd, tbl_regs[get_nibble(inst, 4)],
arminsn->str_asm = r_str_appendf (arminsn->str_asm, " %u, cr%u, [%s], #%d", CPnum, CRd, tbl_regs[get_nibble (inst, 4)],
offset);
return 0;
}
@ -359,19 +394,24 @@ static ut16 thumb_disasm_hireg(struct winedbg_arm_insn *arminsn, ut16 inst) {
short h1 = (inst >> 7) & 0x01;
short op = (inst >> 8) & 0x03;
if (h1) dst += 8;
if (h2) src += 8;
if (h1) {
dst += 8;
}
if (h2) {
src += 8;
}
if (op == 2 && dst == src) { /* mov rx, rx */
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "nop");
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "nop");
return 0;
}
if (op == 3)
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "b%sx %s", h1?"l":"", tbl_regs[src]);
else
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "%s %s, %s", tbl_hiops_t[op], tbl_regs[dst], tbl_regs[src]);
if (op == 3) {
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "b%sx %s", h1?"l":"", tbl_regs[src]);
}
else {
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "%s %s, %s", tbl_hiops_t[op], tbl_regs[dst], tbl_regs[src]);
}
return 0;
}
@ -380,7 +420,7 @@ static ut16 thumb_disasm_aluop(struct winedbg_arm_insn *arminsn, ut16 inst) {
short src = (inst >> 3) & 0x07;
short op = (inst >> 6) & 0x0f;
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "%s %s, %s", tbl_aluops_t[op], tbl_regs[dst], tbl_regs[src]);
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "%s %s, %s", tbl_aluops_t[op], tbl_regs[dst], tbl_regs[src]);
return 0;
}
@ -390,21 +430,30 @@ static ut16 thumb_disasm_pushpop(struct winedbg_arm_insn *arminsn, ut16 inst) {
short i;
short last;
for (i=7;i>=0;i--)
if ((inst>>i) & 1) break;
for (i=7;i>=0;i--) {
if ((inst>>i) & 1) {
break;
}
}
last = i;
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "%s {", load ? "pop" : "push");
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "%s {", load ? "pop" : "push");
for (i=0;i<=7;i++)
for (i=0;i<=7;i++) {
if ((inst>>i) & 1) {
if (i == last) arminsn->str_asm = r_str_appendf(arminsn->str_asm, "%s", tbl_regs[i]);
else arminsn->str_asm = r_str_appendf(arminsn->str_asm, "%s, ", tbl_regs[i]);
if (i == last) {
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "%s", tbl_regs[i]);
}
else {
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "%s, ", tbl_regs[i]);
}
}
if (lrpc)
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "%s%s", last ? ", " : "", load ? "pc" : "lr");
}
if (lrpc) {
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "%s%s", last ? ", " : "", load ? "pc" : "lr");
}
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "}");
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "}");
return 0;
}
@ -413,25 +462,33 @@ static ut16 thumb_disasm_blocktrans(struct winedbg_arm_insn *arminsn, ut16 inst)
short i;
short last;
for (i=7;i>=0;i--)
if ((inst>>i) & 1) break;
for (i=7;i>=0;i--) {
if ((inst>>i) & 1) {
break;
}
}
last = i;
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "%s %s!, {", load ? "ldmia" : "stmia", tbl_regs[(inst >> 8) & 0x07]);
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "%s %s!, {", load ? "ldmia" : "stmia", tbl_regs[(inst >> 8) & 0x07]);
for (i=0;i<=7;i++)
for (i=0;i<=7;i++) {
if ((inst>>i) & 1) {
if (i == last) arminsn->str_asm = r_str_appendf(arminsn->str_asm, "%s", tbl_regs[i]);
else arminsn->str_asm = r_str_appendf(arminsn->str_asm, "%s, ", tbl_regs[i]);
if (i == last) {
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "%s", tbl_regs[i]);
}
else {
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "%s, ", tbl_regs[i]);
}
}
}
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "}");
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "}");
return 0;
}
static ut16 thumb_disasm_condbranch(struct winedbg_arm_insn *arminsn, ut16 inst) {
ut16 offset = inst & 0x00ff;
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "b%s 0x%"PFMT64x, tbl_cond[(inst >> 8) & 0x0f], arminsn->pc+offset);
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "b%s 0x%"PFMT64x, tbl_cond[(inst >> 8) & 0x0f], arminsn->pc+offset);
arminsn->jmp = arminsn->pc+offset;
arminsn->fail = arminsn->pc+4;
@ -441,9 +498,11 @@ static ut16 thumb_disasm_condbranch(struct winedbg_arm_insn *arminsn, ut16 inst)
static ut16 thumb_disasm_uncondbranch(struct winedbg_arm_insn *arminsn, ut16 inst) {
short offset = (inst & 0x07ff) << 1;
if (offset & 0x0800) offset |= 0xf000;
if (offset & 0x0800) {
offset |= 0xf000;
}
offset += 4;
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "b 0x%"PFMT64x, arminsn->pc+offset);
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "b 0x%"PFMT64x, arminsn->pc+offset);
arminsn->jmp = arminsn->pc+offset;
return 0;
@ -453,47 +512,49 @@ static ut16 thumb_disasm_loadadr(struct winedbg_arm_insn *arminsn, ut16 inst) {
ut16 src = (inst >> 11) & 0x01;
ut16 offset = (inst & 0xff) << 2;
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "add %s, %s, #%d", tbl_regs[(inst >> 8) & 0x07], src ? "sp" : "pc",
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "add %s, %s, #%d", tbl_regs[(inst >> 8) & 0x07], src ? "sp" : "pc",
offset);
return 0;
}
static ut16 thumb_disasm_swi(struct winedbg_arm_insn *arminsn, ut16 inst) {
ut16 comment = inst & 0x00ff;
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "swi #%d", comment);
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "swi #%d", comment);
return 0;
}
static ut16 thumb_disasm_nop(struct winedbg_arm_insn *arminsn, ut16 inst) {
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "nop");
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "nop");
return 0;
}
static ut16 thumb_disasm_ldrpcrel(struct winedbg_arm_insn *arminsn, ut16 inst) {
ut16 offset = (inst & 0xff) << 2;
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "ldr %s, [pc, #%u]", tbl_regs[(inst >> 8) & 0x07], offset);
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "ldr %s, [pc, #%u]", tbl_regs[(inst >> 8) & 0x07], offset);
return 0;
}
static ut16 thumb_disasm_ldrsprel(struct winedbg_arm_insn *arminsn, ut16 inst) {
ut16 offset = (inst & 0xff) << 2;
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "%s %s, [sp, #%u]", (inst & 0x0800)?"ldr":"str",
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "%s %s, [sp, #%u]", (inst & 0x0800)?"ldr":"str",
tbl_regs[(inst >> 8) & 0x07], offset);
return 0;
}
static ut16 thumb_disasm_addsprel(struct winedbg_arm_insn *arminsn, ut16 inst) {
ut16 offset = (inst & 0x7f) << 2;
if ((inst >> 7) & 0x01)
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "sub sp, sp, #%u", offset);
else
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "add sp, sp, #%u", offset);
if ((inst >> 7) & 0x01) {
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "sub sp, sp, #%u", offset);
}
else {
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "add sp, sp, #%u", offset);
}
return 0;
}
static ut16 thumb_disasm_ldrimm(struct winedbg_arm_insn *arminsn, ut16 inst) {
ut16 offset = (inst & 0x07c0) >> 6;
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "%s%s %s, [%s, #%u]",
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "%s%s %s, [%s, #%u]",
(inst & 0x0800)?"ldr":"str", (inst & 0x1000)?"b":"",
tbl_regs[inst & 0x07], tbl_regs[(inst >> 3) & 0x07],
(inst & 0x1000)?offset:(offset << 2));
@ -502,13 +563,13 @@ static ut16 thumb_disasm_ldrimm(struct winedbg_arm_insn *arminsn, ut16 inst) {
static ut16 thumb_disasm_ldrhimm(struct winedbg_arm_insn *arminsn, ut16 inst) {
ut16 offset = (inst & 0x07c0) >> 5;
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "%s %s, [%s, #%u]", (inst & 0x0800)?"ldrh":"strh",
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "%s %s, [%s, #%u]", (inst & 0x0800)?"ldrh":"strh",
tbl_regs[inst & 0x07], tbl_regs[(inst >> 3) & 0x07], offset);
return 0;
}
static ut16 thumb_disasm_ldrreg(struct winedbg_arm_insn *arminsn, ut16 inst) {
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "%s%s %s, [%s, %s]",
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "%s%s %s, [%s, %s]",
(inst & 0x0800)?"ldr":"str", (inst & 0x0400)?"b":"",
tbl_regs[inst & 0x07], tbl_regs[(inst >> 3) & 0x07],
tbl_regs[(inst >> 6) & 0x07]);
@ -516,7 +577,7 @@ static ut16 thumb_disasm_ldrreg(struct winedbg_arm_insn *arminsn, ut16 inst) {
}
static ut16 thumb_disasm_ldrsreg(struct winedbg_arm_insn *arminsn, ut16 inst) {
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "%s %s, [%s, %s]",
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "%s %s, [%s, %s]",
tbl_sregops_t[(inst >> 10) & 0x03], tbl_regs[inst & 0x07],
tbl_regs[(inst >> 3) & 0x07], tbl_regs[(inst >> 6) & 0x07]);
return 0;
@ -524,7 +585,7 @@ static ut16 thumb_disasm_ldrsreg(struct winedbg_arm_insn *arminsn, ut16 inst) {
static ut16 thumb_disasm_immop(struct winedbg_arm_insn *arminsn, ut16 inst) {
ut16 op = (inst >> 11) & 0x03;
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "%s %s, #%u", tbl_immops_t[op], tbl_regs[(inst >> 8) & 0x07],
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "%s %s, #%u", tbl_immops_t[op], tbl_regs[(inst >> 8) & 0x07],
inst & 0xff);
return 0;
}
@ -533,25 +594,27 @@ static ut16 thumb_disasm_addsub(struct winedbg_arm_insn *arminsn, ut16 inst) {
ut16 op = (inst >> 9) & 0x01;
ut16 immediate = (inst >> 10) & 0x01;
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "%s %s, %s, ", op ? "sub" : "add",
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "%s %s, %s, ", op ? "sub" : "add",
tbl_regs[inst & 0x07], tbl_regs[(inst >> 3) & 0x07]);
if (immediate)
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "#%d", (inst >> 6) & 0x07);
else
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "%s", tbl_regs[(inst >> 6) & 0x07]);
if (immediate) {
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "#%d", (inst >> 6) & 0x07);
}
else {
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "%s", tbl_regs[(inst >> 6) & 0x07]);
}
return 0;
}
static ut16 thumb_disasm_movshift(struct winedbg_arm_insn *arminsn, ut16 inst) {
ut16 op = (inst >> 11) & 0x03;
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "%s %s, %s, #%u", tbl_shifts[op],
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "%s %s, %s, #%u", tbl_shifts[op],
tbl_regs[inst & 0x07], tbl_regs[(inst >> 3) & 0x07], (inst >> 6) & 0x1f);
return 0;
}
static ut32 thumb2_disasm_branchlinked(struct winedbg_arm_insn *arminsn, ut32 inst) {
ut32 offset = (((inst & 0x07ff0000) >> 4) | ((inst & 0x000007ff) << 1)) + 4;
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "bl 0x%"PFMT64x, arminsn->pc+offset);
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "bl 0x%"PFMT64x, arminsn->pc+offset);
arminsn->jmp = arminsn->pc+offset;
return 0;
@ -561,31 +624,32 @@ static ut32 thumb2_disasm_misc(struct winedbg_arm_insn *arminsn, ut32 inst) {
ut16 op1 = (inst >> 20) & 0x03;
ut16 op2 = (inst >> 4) & 0x03;
if (get_nibble(inst, 4) != get_nibble(inst, 0))
if (get_nibble (inst, 4) != get_nibble (inst, 0)) {
return inst;
}
if (op1 == 3 && op2 == 0) {
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "clz %s, %s ", tbl_regs[get_nibble(inst, 2)],
tbl_regs[get_nibble(inst, 0)]);
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "clz %s, %s ", tbl_regs[get_nibble (inst, 2)],
tbl_regs[get_nibble (inst, 0)]);
return 0;
}
if (op1 == 1) {
switch (op2) {
case 0:
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "rev ");
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "rev ");
break;
case 1:
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "rev16 ");
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "rev16 ");
break;
case 2:
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "rbit ");
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "rbit ");
break;
case 3:
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "revsh ");
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "revsh ");
break;
}
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "%s, %s ", tbl_regs[get_nibble(inst, 2)], tbl_regs[get_nibble(inst, 0)]);
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "%s, %s ", tbl_regs[get_nibble (inst, 2)], tbl_regs[get_nibble (inst, 0)]);
return 0;
}
@ -596,29 +660,30 @@ static ut32 thumb2_disasm_mul(struct winedbg_arm_insn *arminsn, ut32 inst) {
ut16 op1 = (inst >> 20) & 0x07;
ut16 op2 = (inst >> 4) & 0x03;
if (op1)
if (op1) {
return inst;
}
if (op2 == 0 && get_nibble(inst, 3) != 0xf) {
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "mla %s, %s, %s, %s ", tbl_regs[get_nibble(inst, 2)],
tbl_regs[get_nibble(inst, 4)],
tbl_regs[get_nibble(inst, 0)],
tbl_regs[get_nibble(inst, 3)]);
if (op2 == 0 && get_nibble (inst, 3) != 0xf) {
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "mla %s, %s, %s, %s ", tbl_regs[get_nibble (inst, 2)],
tbl_regs[get_nibble (inst, 4)],
tbl_regs[get_nibble (inst, 0)],
tbl_regs[get_nibble (inst, 3)]);
return 0;
}
if (op2 == 0 && get_nibble(inst, 3) == 0xf) {
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "mul %s, %s, %s ", tbl_regs[get_nibble(inst, 2)],
tbl_regs[get_nibble(inst, 4)],
tbl_regs[get_nibble(inst, 0)]);
if (op2 == 0 && get_nibble (inst, 3) == 0xf) {
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "mul %s, %s, %s ", tbl_regs[get_nibble (inst, 2)],
tbl_regs[get_nibble (inst, 4)],
tbl_regs[get_nibble (inst, 0)]);
return 0;
}
if (op2 == 1) {
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "mls %s, %s, %s, %s ", tbl_regs[get_nibble(inst, 2)],
tbl_regs[get_nibble(inst, 4)],
tbl_regs[get_nibble(inst, 0)],
tbl_regs[get_nibble(inst, 3)]);
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "mls %s, %s, %s, %s ", tbl_regs[get_nibble (inst, 2)],
tbl_regs[get_nibble (inst, 4)],
tbl_regs[get_nibble (inst, 0)],
tbl_regs[get_nibble (inst, 3)]);
return 0;
}
@ -632,39 +697,39 @@ static ut32 thumb2_disasm_longmuldiv(struct winedbg_arm_insn *arminsn, ut32 inst
if (op2 == 0) {
switch (op1) {
case 0:
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "smull ");
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "smull ");
break;
case 2:
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "umull ");
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "umull ");
break;
case 4:
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "smlal ");
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "smlal ");
break;
case 6:
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "umlal ");
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "umlal ");
break;
default:
return inst;
}
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "%s, %s, %s, %s ",
tbl_regs[get_nibble(inst, 3)], tbl_regs[get_nibble(inst, 2)],
tbl_regs[get_nibble(inst, 4)], tbl_regs[get_nibble(inst, 0)]);
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "%s, %s, %s, %s ",
tbl_regs[get_nibble (inst, 3)], tbl_regs[get_nibble (inst, 2)],
tbl_regs[get_nibble (inst, 4)], tbl_regs[get_nibble (inst, 0)]);
return 0;
}
if (op2 == 0xffff) {
switch (op1) {
case 1:
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "sdiv ");
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "sdiv ");
break;
case 3:
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "udiv ");
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "udiv ");
break;
default:
return inst;
}
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "%s, %s, %s ", tbl_regs[get_nibble(inst, 2)], tbl_regs[get_nibble(inst, 4)],
tbl_regs[get_nibble(inst, 0)]);
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "%s, %s, %s ", tbl_regs[get_nibble (inst, 2)], tbl_regs[get_nibble (inst, 4)],
tbl_regs[get_nibble (inst, 0)]);
return 0;
}
@ -675,16 +740,18 @@ static ut32 thumb2_disasm_coprocmov1(struct winedbg_arm_insn *arminsn, ut32 inst
ut16 opc1 = (inst >> 21) & 0x07;
ut16 opc2 = (inst >> 5) & 0x07;
if (opc2)
arminsn->str_asm = r_str_appendf(arminsn->str_asm,
if (opc2) {
arminsn->str_asm = r_str_appendf (arminsn->str_asm,
"%s%s\tp%u, #%u, %s, cr%u, cr%u, #%u", (inst & 0x00100000)?"mrc":"mcr",
(inst & 0x10000000)?"2":"", get_nibble(inst, 2), opc1,
tbl_regs[get_nibble(inst, 3)], get_nibble(inst, 4), get_nibble(inst, 0), opc2);
else
arminsn->str_asm = r_str_appendf(arminsn->str_asm,
(inst & 0x10000000)?"2":"", get_nibble (inst, 2), opc1,
tbl_regs[get_nibble (inst, 3)], get_nibble (inst, 4), get_nibble (inst, 0), opc2);
}
else {
arminsn->str_asm = r_str_appendf (arminsn->str_asm,
"%s%s\tp%u, #%u, %s, cr%u, cr%u", (inst & 0x00100000)?"mrc":"mcr",
(inst & 0x10000000)?"2":"", get_nibble(inst, 2), opc1,
tbl_regs[get_nibble(inst, 3)], get_nibble(inst, 4), get_nibble(inst, 0));
(inst & 0x10000000)?"2":"", get_nibble (inst, 2), opc1,
tbl_regs[get_nibble (inst, 3)], get_nibble (inst, 4), get_nibble (inst, 0));
}
return 0;
}
@ -814,10 +881,13 @@ int arm_disasm_one_insn(struct winedbg_arm_insn *arminsn) {
a_ptr++;
}
if (!matched)
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "Unknown ARM Instruction: %08x", inst);
else a_ptr->func(arminsn, inst);
arminsn->str_hex = r_str_appendf(arminsn->str_hex, "%02x%02x%02x%02x",
if (!matched) {
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "Unknown ARM Instruction: %08x", inst);
}
else {
a_ptr->func(arminsn, inst);
}
arminsn->str_hex = r_str_appendf (arminsn->str_hex, "%02x%02x%02x%02x",
*((ut8*)(&inst)), *((ut8*)(&inst)+1), *((ut8*)(&inst)+2), *((ut8*)(&inst)+3));
return size;
} else {
@ -838,10 +908,13 @@ int arm_disasm_one_insn(struct winedbg_arm_insn *arminsn) {
t2_ptr++;
}
if (!matched)
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "Unknown Thumb2 Instruction: %08x", inst);
else t2_ptr->func(arminsn, inst);
arminsn->str_hex = r_str_appendf(arminsn->str_hex, "%02x%02x%02x%02x",
if (!matched) {
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "Unknown Thumb2 Instruction: %08x", inst);
}
else {
t2_ptr->func(arminsn, inst);
}
arminsn->str_hex = r_str_appendf (arminsn->str_hex, "%02x%02x%02x%02x",
*((ut8*)(&inst)), *((ut8*)(&inst)+1), *((ut8*)(&inst)+2), *((ut8*)(&inst)+3));
return size;
default:
@ -857,10 +930,13 @@ int arm_disasm_one_insn(struct winedbg_arm_insn *arminsn) {
t_ptr++;
}
if (!matched)
arminsn->str_asm = r_str_appendf(arminsn->str_asm, "Unknown Thumb Instruction: %04x", tinst);
else t_ptr->func(arminsn, tinst);
arminsn->str_hex = r_str_appendf(arminsn->str_hex, "%02x%02x", *((ut8*)(&tinst)), *((ut8*)(&tinst)+1));
if (!matched) {
arminsn->str_asm = r_str_appendf (arminsn->str_asm, "Unknown Thumb Instruction: %04x", tinst);
}
else {
t_ptr->func(arminsn, tinst);
}
arminsn->str_hex = r_str_appendf (arminsn->str_hex, "%02x%02x", *((ut8*)(&tinst)), *((ut8*)(&tinst)+1));
return size;
}
return size;

206
libr/bin/dwarf.c
View File

@ -234,15 +234,15 @@ static const ut8 *r_bin_dwarf_parse_lnp_header (
hdr->opcode_base = READ (buf, ut8);
if (f) {
fprintf(f, "DWARF LINE HEADER\n");
fprintf(f, " total_length: %d\n", hdr->unit_length.part1);
fprintf(f, " version: %d\n", hdr->version);
fprintf(f, " header_length: : %"PFMT64d"\n", hdr->header_length);
fprintf(f, " mininstlen: %d\n", hdr->min_inst_len);
fprintf(f, " is_stmt: %d\n", hdr->default_is_stmt);
fprintf(f, " line_base: %d\n", hdr->line_base);
fprintf(f, " line_range: %d\n", hdr->line_range);
fprintf(f, " opcode_base: %d\n", hdr->opcode_base);
fprintf (f, "DWARF LINE HEADER\n");
fprintf (f, " total_length: %d\n", hdr->unit_length.part1);
fprintf (f, " version: %d\n", hdr->version);
fprintf (f, " header_length: : %"PFMT64d"\n", hdr->header_length);
fprintf (f, " mininstlen: %d\n", hdr->min_inst_len);
fprintf (f, " is_stmt: %d\n", hdr->default_is_stmt);
fprintf (f, " line_base: %d\n", hdr->line_base);
fprintf (f, " line_range: %d\n", hdr->line_range);
fprintf (f, " opcode_base: %d\n", hdr->opcode_base);
}
if (hdr->opcode_base>0) {
@ -252,7 +252,7 @@ static const ut8 *r_bin_dwarf_parse_lnp_header (
if (buf+2>buf_end) break;
hdr->std_opcode_lengths[i] = READ (buf, ut8);
if (f) {
fprintf(f, " op %d %d\n", i, hdr->std_opcode_lengths[i]);
fprintf (f, " op %d %d\n", i, hdr->std_opcode_lengths[i]);
}
}
} else {
@ -443,7 +443,7 @@ static const ut8* r_bin_dwarf_parse_ext_opcode(const RBin *a, const ut8 *obuf,
}
if (f) {
fprintf(f, "End of Sequence\n");
fprintf (f, "End of Sequence\n");
}
break;
case DW_LNE_set_address:
@ -456,15 +456,15 @@ static const ut8* r_bin_dwarf_parse_ext_opcode(const RBin *a, const ut8 *obuf,
regs->address = addr;
if (f) {
fprintf(f, "set Address to 0x%"PFMT64x"\n", addr);
fprintf (f, "set Address to 0x%"PFMT64x"\n", addr);
}
break;
case DW_LNE_define_file:
filename = (const char*)buf;
if (f) {
fprintf(f, "define_file\n");
fprintf(f, "filename %s\n", filename);
fprintf (f, "define_file\n");
fprintf (f, "filename %s\n", filename);
}
buf += (strlen (filename) + 1);
@ -473,15 +473,15 @@ static const ut8* r_bin_dwarf_parse_ext_opcode(const RBin *a, const ut8 *obuf,
buf = r_uleb128 (buf, ST32_MAX, &dir_idx);
break;
case DW_LNE_set_discriminator:
buf = r_uleb128(buf, ST32_MAX, &addr);
buf = r_uleb128 (buf, ST32_MAX, &addr);
if (f) {
fprintf(f, "set Discriminator to %"PFMT64d"\n", addr);
fprintf (f, "set Discriminator to %"PFMT64d"\n", addr);
}
regs->discriminator = addr;
break;
default:
if (f) {
fprintf(f, "Unexpeced opcode %d\n", opcode);
fprintf (f, "Unexpeced opcode %d\n", opcode);
}
break;
}
@ -578,32 +578,32 @@ static const ut8* r_bin_dwarf_parse_std_opcode(
buf = r_leb128(buf, &sbuf);
regs->line += sbuf;
if (f) {
fprintf(f, "Advance line by %"PFMT64d", to %"PFMT64d"\n", sbuf, regs->line);
fprintf (f, "Advance line by %"PFMT64d", to %"PFMT64d"\n", sbuf, regs->line);
}
break;
case DW_LNS_set_file:
buf = r_uleb128 (buf, ST32_MAX, &addr);
if (f) {
fprintf(f, "Set file to %"PFMT64d"\n", addr);
fprintf (f, "Set file to %"PFMT64d"\n", addr);
}
regs->file = addr;
break;
case DW_LNS_set_column:
buf = r_uleb128(buf, ST32_MAX, &addr);
buf = r_uleb128 (buf, ST32_MAX, &addr);
if (f) {
fprintf(f, "Set column to %"PFMT64d"\n", addr);
fprintf (f, "Set column to %"PFMT64d"\n", addr);
}
regs->column = addr;
break;
case DW_LNS_negate_stmt:
regs->is_stmt = regs->is_stmt ? DWARF_FALSE : DWARF_TRUE;
if (f) {
fprintf(f, "Set is_stmt to %d\n", regs->is_stmt);
fprintf (f, "Set is_stmt to %d\n", regs->is_stmt);
}
break;
case DW_LNS_set_basic_block:
if (f) {
fprintf(f, "set_basic_block\n");
fprintf (f, "set_basic_block\n");
}
regs->basic_block = DWARF_TRUE;
break;
@ -616,7 +616,7 @@ static const ut8* r_bin_dwarf_parse_std_opcode(
}
regs->address += op_advance;
if (f) {
fprintf(f, "Advance PC by constant %"PFMT64d" to 0x%"PFMT64x"\n",
fprintf (f, "Advance PC by constant %"PFMT64d" to 0x%"PFMT64x"\n",
op_advance, regs->address);
}
break;
@ -624,31 +624,31 @@ static const ut8* r_bin_dwarf_parse_std_opcode(
operand = READ (buf, ut16);
regs->address += operand;
if (f) {
fprintf(f,"Fixed advance pc to %"PFMT64d"\n", regs->address);
fprintf (f,"Fixed advance pc to %"PFMT64d"\n", regs->address);
}
break;
case DW_LNS_set_prologue_end:
regs->prologue_end = ~0;
if (f) {
fprintf(f, "set_prologue_end\n");
fprintf (f, "set_prologue_end\n");
}
break;
case DW_LNS_set_epilogue_begin:
regs->epilogue_begin = ~0;
if (f) {
fprintf(f, "set_epilogue_begin\n");
fprintf (f, "set_epilogue_begin\n");
}
break;
case DW_LNS_set_isa:
buf = r_uleb128 (buf, ST32_MAX, &addr);
regs->isa = addr;
if (f) {
fprintf(f, "set_isa\n");
fprintf (f, "set_isa\n");
}
break;
default:
if (f) {
fprintf(f, "Unexpected opcode\n");
fprintf (f, "Unexpected opcode\n");
}
break;
}
@ -759,31 +759,41 @@ R_API int r_bin_dwarf_parse_aranges_raw(const ut8 *obuf, int len, FILE *f) {
return false;
READ_BUF (version, ut16);
if (f) printf("Version %d\n", version);
if (f) {
printf("Version %d\n", version);
}
READ_BUF (debug_info_offset, ut32);
if (f) fprintf(f, "Debug info offset %d\n", debug_info_offset);
if (f) {
fprintf (f, "Debug info offset %d\n", debug_info_offset);
}
READ_BUF (address_size, ut8);
if (f) fprintf(f, "address size %d\n", (int)address_size);
if (f) {
fprintf (f, "address size %d\n", (int)address_size);
}
READ_BUF (segment_size, ut8);
if (f) fprintf(f, "segment size %d\n", (int)segment_size);
if (f) {
fprintf (f, "segment size %d\n", (int)segment_size);
}
offset = segment_size + address_size * 2;
if (offset) {
ut64 n = (((ut64) (size_t)buf / offset) + 1) * offset - ((ut64)(size_t)buf);
if (idx+n>=len)
if (idx+n>=len) {
return false;
}
buf += n;
idx += n;
}
while ((buf - obuf) < len) {
ut64 adr, length;
if ((idx+8)>=len)
if ((idx+8)>=len) {
break;
}
READ_BUF (adr, ut64);
READ_BUF (length, ut64);
if (f) printf("length 0x%"PFMT64x" address 0x%"PFMT64x"\n", length, adr);
@ -793,11 +803,15 @@ R_API int r_bin_dwarf_parse_aranges_raw(const ut8 *obuf, int len, FILE *f) {
}
static int r_bin_dwarf_init_debug_info(RBinDwarfDebugInfo *inf) {
if (!inf) return -1;
inf->comp_units = calloc (sizeof(RBinDwarfCompUnit), DEBUG_INFO_CAPACITY);
if (!inf) {
return -1;
}
inf->comp_units = calloc (sizeof (RBinDwarfCompUnit), DEBUG_INFO_CAPACITY);
// XXX - should we be using error codes?
if (!inf->comp_units) return -ENOMEM;
if (!inf->comp_units) {
return -ENOMEM;
}
inf->capacity = DEBUG_INFO_CAPACITY;
inf->length = 0;
@ -852,12 +866,16 @@ static int r_bin_dwarf_init_comp_unit(RBinDwarfCompUnit *cu) {
static int r_bin_dwarf_expand_cu(RBinDwarfCompUnit *cu) {
RBinDwarfDIE *tmp;
if (!cu || cu->capacity == 0 || cu->capacity != cu->length) return -EINVAL;
if (!cu || cu->capacity == 0 || cu->capacity != cu->length) {
return -EINVAL;
}
tmp = (RBinDwarfDIE*)realloc(cu->dies,
cu->capacity * 2 * sizeof(RBinDwarfDIE));
if (!tmp) return -ENOMEM;
if (!tmp) {
return -ENOMEM;
}
cu->dies = tmp;
cu->capacity *= 2;
@ -866,11 +884,14 @@ static int r_bin_dwarf_expand_cu(RBinDwarfCompUnit *cu) {
}
static int r_bin_dwarf_init_abbrev_decl(RBinDwarfAbbrevDecl *ad) {
if (!ad) return -EINVAL;
ad->specs = calloc(sizeof(RBinDwarfAttrSpec), ABBREV_DECL_CAP);
if (!ad) {
return -EINVAL;
}
ad->specs = calloc (sizeof( RBinDwarfAttrSpec), ABBREV_DECL_CAP);
if (!ad->specs)
if (!ad->specs) {
return -ENOMEM;
}
ad->capacity = ABBREV_DECL_CAP;
ad->length = 0;
@ -881,14 +902,16 @@ static int r_bin_dwarf_init_abbrev_decl(RBinDwarfAbbrevDecl *ad) {
static int r_bin_dwarf_expand_abbrev_decl(RBinDwarfAbbrevDecl *ad) {
RBinDwarfAttrSpec *tmp;
if (!ad || ad->capacity==0 || ad->capacity != ad->length)
if (!ad || ad->capacity==0 || ad->capacity != ad->length) {
return -EINVAL;
}
tmp = (RBinDwarfAttrSpec*)realloc(ad->specs,
ad->capacity * 2 * sizeof(RBinDwarfAttrSpec));
tmp = (RBinDwarfAttrSpec*)realloc (ad->specs,
ad->capacity * 2 * sizeof (RBinDwarfAttrSpec));
if (!tmp)
if (!tmp) {
return -ENOMEM;
}
ad->specs = tmp;
ad->capacity *= 2;
@ -897,7 +920,9 @@ static int r_bin_dwarf_expand_abbrev_decl(RBinDwarfAbbrevDecl *ad) {
}
static int r_bin_dwarf_init_debug_abbrev(RBinDwarfDebugAbbrev *da) {
if (!da) return -EINVAL;
if (!da) {
return -EINVAL;
}
da->decls = calloc (sizeof (RBinDwarfAbbrevDecl), DEBUG_ABBREV_CAP);
if (!da->decls) {
return -ENOMEM;
@ -911,14 +936,16 @@ static int r_bin_dwarf_init_debug_abbrev(RBinDwarfDebugAbbrev *da) {
static int r_bin_dwarf_expand_debug_abbrev(RBinDwarfDebugAbbrev *da) {
RBinDwarfAbbrevDecl *tmp;
if (!da || da->capacity == 0 || da->capacity != da->length)
if (!da || da->capacity == 0 || da->capacity != da->length) {
return -EINVAL;
}
tmp = (RBinDwarfAbbrevDecl*)realloc (da->decls,
da->capacity * 2 * sizeof (RBinDwarfAbbrevDecl));
if (!tmp)
if (!tmp) {
return -ENOMEM;
}
da->decls = tmp;
da->capacity *= 2;
@ -930,15 +957,18 @@ static void dump_r_bin_dwarf_debug_abbrev(FILE *f, RBinDwarfDebugAbbrev *da) {
size_t i, j;
ut64 attr_name, attr_form;
if (!f || !da) return;
if (!f || !da) {
return;
}
for (i = 0; i < da->length; i++) {
int declstag = da->decls[i].tag;
fprintf(f, "Abbreviation Code %"PFMT64d" ", da->decls[i].code);
if (declstag>=0 && declstag < DW_TAG_LAST)
fprintf(f, "Tag %s ", dwarf_tag_name_encodings[declstag]);
fprintf(f, "[%s]\n", da->decls[i].has_children ?
fprintf (f, "Abbreviation Code %"PFMT64d" ", da->decls[i].code);
if (declstag>=0 && declstag < DW_TAG_LAST) {
fprintf (f, "Tag %s ", dwarf_tag_name_encodings[declstag]);
}
fprintf (f, "[%s]\n", da->decls[i].has_children ?
"has children" : "no children");
fprintf(f, "Offset 0x%"PFMT64x"\n", da->decls[i].offset);
fprintf (f, "Offset 0x%"PFMT64x"\n", da->decls[i].offset);
for (j = 0; j < da->decls[i].length; j++) {
attr_name = da->decls[i].specs[j].attr_name;
@ -946,7 +976,7 @@ static void dump_r_bin_dwarf_debug_abbrev(FILE *f, RBinDwarfDebugAbbrev *da) {
if (attr_name && attr_form &&
attr_name <= DW_AT_vtable_elem_location &&
attr_form <= DW_FORM_indirect) {
fprintf(f, " %s %s\n",
fprintf (f, " %s %s\n",
dwarf_attr_encodings[attr_name],
dwarf_attr_form_encodings[attr_form]);
}
@ -983,7 +1013,9 @@ static void r_bin_dwarf_free_attr_value(RBinDwarfAttrValue *val) {
static void r_bin_dwarf_free_die (RBinDwarfDIE *die) {
size_t i;
if (!die) return;
if (!die) {
return;
}
for (i = 0; i < die->length; i++) {
r_bin_dwarf_free_attr_value (&die->attr_values[i]);
}
@ -992,7 +1024,9 @@ static void r_bin_dwarf_free_die (RBinDwarfDIE *die) {
static void r_bin_dwarf_free_comp_unit (RBinDwarfCompUnit *cu) {
size_t i;
if (!cu) return;
if (!cu) {
return;
}
for (i = 0; i < cu->length; i++) {
r_bin_dwarf_free_die (&cu->dies[i]);
}
@ -1001,7 +1035,9 @@ static void r_bin_dwarf_free_comp_unit (RBinDwarfCompUnit *cu) {
static void r_bin_dwarf_free_debug_info (RBinDwarfDebugInfo *inf) {
size_t i;
if (!inf) return;
if (!inf) {
return;
}
for (i = 0; i < inf->length; i++) {
r_bin_dwarf_free_comp_unit (&inf->comp_units[i]);
}
@ -1010,10 +1046,12 @@ static void r_bin_dwarf_free_debug_info (RBinDwarfDebugInfo *inf) {
static void r_bin_dwarf_dump_attr_value(const RBinDwarfAttrValue *val, FILE *f) {
size_t i;
if (!val || !f) return;
if (!val || !f) {
return;
}
switch (val->form) {
case DW_FORM_addr:
fprintf(f, "0x%"PFMT64x"", val->encoding.address);
fprintf (f, "0x%"PFMT64x"", val->encoding.address);
break;
case DW_FORM_block:
case DW_FORM_block1:
@ -1070,25 +1108,27 @@ static void r_bin_dwarf_dump_debug_info(FILE *f, const RBinDwarfDebugInfo *inf)
size_t i, j, k;
RBinDwarfDIE *dies;
RBinDwarfAttrValue *values;
if (!inf || !f) return;
if (!inf || !f) {
return;
}
for (i = 0; i < inf->length; i++) {
fprintf(f, " Compilation Unit @ offset 0x%"PFMT64x":\n", inf->comp_units [i].offset);
fprintf(f, " Length: 0x%x\n", inf->comp_units [i].hdr.length);
fprintf(f, " Version: %d\n", inf->comp_units [i].hdr.version);
fprintf(f, " Abbrev Offset: 0x%x\n", inf->comp_units [i].hdr.abbrev_offset);
fprintf(f, " Pointer Size: %d\n", inf->comp_units [i].hdr.pointer_size);
fprintf (f, " Compilation Unit @ offset 0x%"PFMT64x":\n", inf->comp_units [i].offset);
fprintf (f, " Length: 0x%x\n", inf->comp_units [i].hdr.length);
fprintf (f, " Version: %d\n", inf->comp_units [i].hdr.version);
fprintf (f, " Abbrev Offset: 0x%x\n", inf->comp_units [i].hdr.abbrev_offset);
fprintf (f, " Pointer Size: %d\n", inf->comp_units [i].hdr.pointer_size);
dies = inf->comp_units[i].dies;
for (j = 0; j < inf->comp_units[i].length; j++) {
fprintf(f, " Abbrev Number: %"PFMT64u" ", dies[j].abbrev_code);
fprintf (f, " Abbrev Number: %"PFMT64u" ", dies[j].abbrev_code);
if (dies[j].tag && dies[j].tag <= DW_TAG_volatile_type &&
dwarf_tag_name_encodings[dies[j].tag]) {
fprintf(f, "(%s)\n", dwarf_tag_name_encodings[dies[j].tag]);
fprintf (f, "(%s)\n", dwarf_tag_name_encodings[dies[j].tag]);
} else {
fprintf(f, "(Unknown abbrev tag)\n");
fprintf (f, "(Unknown abbrev tag)\n");
}
if (!dies[j].abbrev_code)
@ -1101,12 +1141,12 @@ static void r_bin_dwarf_dump_debug_info(FILE *f, const RBinDwarfDebugInfo *inf)
if (values[k].name < DW_AT_vtable_elem_location &&
dwarf_attr_encodings[values[k].name]) {
fprintf(f, " %-18s : ", dwarf_attr_encodings[values[k].name]);
fprintf (f, " %-18s : ", dwarf_attr_encodings[values[k].name]);
} else {
fprintf(f, " TODO\t");
fprintf (f, " TODO\t");
}
r_bin_dwarf_dump_attr_value (&values[k], f);
fprintf(f, "\n");
fprintf (f, "\n");
}
}
}
@ -1183,7 +1223,7 @@ static const ut8 *r_bin_dwarf_parse_attr_value(const ut8 *obuf, int obuf_len,
break;
case DW_FORM_string:
value->encoding.str_struct.string = *buf? strdup ((const char*)buf) : NULL;
buf += (strlen((const char*)buf) + 1);
buf += (strlen ((const char*)buf) + 1);
break;
case DW_FORM_block:
buf = r_uleb128 (buf, buf_end - buf, &value->encoding.block.length);
@ -1314,7 +1354,9 @@ R_API int r_bin_dwarf_parse_info_raw(Sdb *s, RBinDwarfDebugAbbrev *da,
RBinDwarfDebugInfo *inf = NULL, di;
inf = &di;
if (!da || !s || !obuf) return false;
if (!da || !s || !obuf) {
return false;
}
r_bin_dwarf_init_debug_info (inf);
while (buf < buf_end) {
@ -1380,7 +1422,9 @@ static RBinDwarfDebugAbbrev *r_bin_dwarf_parse_abbrev_raw(const ut8 *obuf, size_
RBinDwarfDebugAbbrev *da = NULL;
// XXX - Set a suitable value here.
if (!obuf || len < 3) return da;
if (!obuf || len < 3) {
return da;
}
da = R_NEW0(RBinDwarfDebugAbbrev);
@ -1412,8 +1456,8 @@ static RBinDwarfDebugAbbrev *r_bin_dwarf_parse_abbrev_raw(const ut8 *obuf, size_
if (tmpdecl->length == tmpdecl->capacity)
r_bin_dwarf_expand_abbrev_decl(tmpdecl);
buf = r_uleb128(buf, (size_t)(buf_end-buf), &spec1);
buf = r_uleb128(buf, (size_t)(buf_end-buf), &spec2);
buf = r_uleb128 (buf, (size_t)(buf_end-buf), &spec1);
buf = r_uleb128 (buf, (size_t)(buf_end-buf), &spec2);
tmpdecl->specs[tmpdecl->length].attr_name = spec1;
tmpdecl->specs[tmpdecl->length].attr_form = spec2;
@ -1490,7 +1534,9 @@ R_API int r_bin_dwarf_parse_info(RBinDwarfDebugAbbrev *da, RBin *a, int mode) {
static RBinDwarfRow *r_bin_dwarf_row_new (ut64 addr, const char *file, int line, int col) {
RBinDwarfRow *row = R_NEW0 (RBinDwarfRow);
if (!row) return NULL;
if (!row) {
return NULL;
}
row->file = strdup (file);
row->address = addr;
row->line = line;

429
libr/bin/mangling/microsoft_demangle.c
View File

@ -158,7 +158,7 @@ copy_string_err:
}
///////////////////////////////////////////////////////////////////////////////
int get_template(char *buf, SStrInfo *str_info) {
int get_template (char *buf, SStrInfo *str_info) {
int len = 0;
unsigned int i = 0;
char *str_type_code = 0;
@ -245,11 +245,11 @@ int get_namespace_and_name( char *buf, STypeCodeStr *type_code_str,
names_l = r_list_new();
#define SET_OPERATOR_CODE(str) { \
str_info = (SStrInfo *) malloc(sizeof(SStrInfo)); \
str_info = (SStrInfo *) malloc (sizeof(SStrInfo)); \
if (!str_info) break; \
str_info->len = strlen(str); \
str_info->len = strlen (str); \
str_info->str_ptr = str; \
r_list_append(names_l, str_info); \
r_list_append (names_l, str_info); \
}
// C++ operator code (one character, or two if the first is '_')
@ -295,14 +295,14 @@ int get_namespace_and_name( char *buf, STypeCodeStr *type_code_str,
case '$':
{
int i = 0;
str_info = (SStrInfo *) malloc(sizeof(SStrInfo));
str_info = (SStrInfo *) malloc (sizeof(SStrInfo));
if (!str_info) break;
i = get_template(buf + 1, str_info);
i = get_template (buf + 1, str_info);
if (!i) {
R_FREE(str_info);
R_FREE (str_info);
goto get_namespace_and_name_err;
}
r_list_append(names_l, str_info);
r_list_append (names_l, str_info);
buf += i;
read_len += i;
break;
@ -310,35 +310,35 @@ int get_namespace_and_name( char *buf, STypeCodeStr *type_code_str,
case '_':
switch (*++buf)
{
case '0': SET_OPERATOR_CODE("operator/="); break;
case '1': SET_OPERATOR_CODE("operator%="); break;
case '2': SET_OPERATOR_CODE("operator>>="); break;
case '3': SET_OPERATOR_CODE("operator<<="); break;
case '4': SET_OPERATOR_CODE("operator&="); break;
case '5': SET_OPERATOR_CODE("operator|="); break;
case '6': SET_OPERATOR_CODE("operator^="); break;
case '7': SET_OPERATOR_CODE("vftable"); break;
case '8': SET_OPERATOR_CODE("vbtable"); break;
case '9': SET_OPERATOR_CODE("vcall"); break;
case 'A': SET_OPERATOR_CODE("typeof"); break;
case 'B': SET_OPERATOR_CODE("local_static_guard"); break;
case 'C': SET_OPERATOR_CODE("string"); break;
case 'D': SET_OPERATOR_CODE("vbase_dtor"); break;
case 'E': SET_OPERATOR_CODE("vector_dtor"); break;
case 'G': SET_OPERATOR_CODE("scalar_dtor"); break;
case 'H': SET_OPERATOR_CODE("vector_ctor_iter"); break;
case 'I': SET_OPERATOR_CODE("vector_dtor_iter"); break;
case 'J': SET_OPERATOR_CODE("vector_vbase_ctor_iter"); break;
case 'L': SET_OPERATOR_CODE("eh_vector_ctor_iter"); break;
case 'M': SET_OPERATOR_CODE("eh_vector_dtor_iter"); break;
case 'N': SET_OPERATOR_CODE("eh_vector_vbase_ctor_iter"); break;
case 'O': SET_OPERATOR_CODE("copy_ctor_closure"); break;
case 'S': SET_OPERATOR_CODE("local_vftable"); break;
case 'T': SET_OPERATOR_CODE("local_vftable_ctor_closure"); break;
case 'U': SET_OPERATOR_CODE("operator new[]"); break;
case 'V': SET_OPERATOR_CODE("operator delete[]"); break;
case 'X': SET_OPERATOR_CODE("placement_new_closure"); break;
case 'Y': SET_OPERATOR_CODE("placement_delete_closure"); break;
case '0': SET_OPERATOR_CODE ("operator/="); break;
case '1': SET_OPERATOR_CODE ("operator%="); break;
case '2': SET_OPERATOR_CODE ("operator>>="); break;
case '3': SET_OPERATOR_CODE ("operator<<="); break;
case '4': SET_OPERATOR_CODE ("operator&="); break;
case '5': SET_OPERATOR_CODE ("operator|="); break;
case '6': SET_OPERATOR_CODE ("operator^="); break;
case '7': SET_OPERATOR_CODE ("vftable"); break;
case '8': SET_OPERATOR_CODE ("vbtable"); break;
case '9': SET_OPERATOR_CODE ("vcall"); break;
case 'A': SET_OPERATOR_CODE ("typeof"); break;
case 'B': SET_OPERATOR_CODE ("local_static_guard"); break;
case 'C': SET_OPERATOR_CODE ("string"); break;
case 'D': SET_OPERATOR_CODE ("vbase_dtor"); break;
case 'E': SET_OPERATOR_CODE ("vector_dtor"); break;
case 'G': SET_OPERATOR_CODE ("scalar_dtor"); break;
case 'H': SET_OPERATOR_CODE ("vector_ctor_iter"); break;
case 'I': SET_OPERATOR_CODE ("vector_dtor_iter"); break;
case 'J': SET_OPERATOR_CODE ("vector_vbase_ctor_iter"); break;
case 'L': SET_OPERATOR_CODE ("eh_vector_ctor_iter"); break;
case 'M': SET_OPERATOR_CODE ("eh_vector_dtor_iter"); break;
case 'N': SET_OPERATOR_CODE ("eh_vector_vbase_ctor_iter"); break;
case 'O': SET_OPERATOR_CODE ("copy_ctor_closure"); break;
case 'S': SET_OPERATOR_CODE ("local_vftable"); break;
case 'T': SET_OPERATOR_CODE ("local_vftable_ctor_closure"); break;
case 'U': SET_OPERATOR_CODE ("operator new[]"); break;
case 'V': SET_OPERATOR_CODE ("operator delete[]"); break;
case 'X': SET_OPERATOR_CODE ("placement_new_closure"); break;
case 'Y': SET_OPERATOR_CODE ("placement_delete_closure"); break;
default:
r_list_free (names_l);
return 0;
@ -355,7 +355,7 @@ int get_namespace_and_name( char *buf, STypeCodeStr *type_code_str,
#undef SET_OPERATOR_CODE
prev_pos = buf;
curr_pos = strchr(buf, '@');
curr_pos = strchr (buf, '@');
// hack for nested templates
// think about how better to fix this...
@ -381,13 +381,13 @@ int get_namespace_and_name( char *buf, STypeCodeStr *type_code_str,
// check is it teamplate???
if ((*tmp == '?') && (*(tmp + 1) == '$')) {
int i = 0;
str_info = (SStrInfo *) malloc(sizeof(SStrInfo));
i = get_template(tmp + 2, str_info);
str_info = (SStrInfo *) malloc (sizeof(SStrInfo));
i = get_template (tmp + 2, str_info);
if (!i) {
R_FREE(str_info);
R_FREE (str_info);
goto get_namespace_and_name_err;
}
r_list_append(names_l, str_info);
r_list_append (names_l, str_info);
prev_pos = tmp + i + 2;
curr_pos = strchr(prev_pos, '@');
@ -397,24 +397,24 @@ int get_namespace_and_name( char *buf, STypeCodeStr *type_code_str,
continue;
}
if (isdigit((int)*tmp)) {
tmp = r_list_get_n(abbr_names, *tmp - '0');
if (isdigit ((int)*tmp)) {
tmp = r_list_get_n (abbr_names, *tmp - '0');
if (!tmp) {
goto get_namespace_and_name_err;
}
len = 1;
} else {
tmp = (char *) malloc(len + 1);
memset(tmp, 0, len + 1);
memcpy(tmp, prev_pos, len);
r_list_append(abbr_names, tmp);
tmp = (char *) malloc (len + 1);
memset (tmp, 0, len + 1);
memcpy (tmp, prev_pos, len);
r_list_append (abbr_names, tmp);
}
str_info = (SStrInfo *) malloc(sizeof(SStrInfo));
str_info = (SStrInfo *) malloc (sizeof (SStrInfo));
str_info->str_ptr = tmp;
str_info->len = strlen(tmp);
str_info->len = strlen (tmp);
r_list_append(names_l, str_info);
r_list_append (names_l, str_info);
read_len += len;
if (len == 1) {
@ -426,21 +426,24 @@ int get_namespace_and_name( char *buf, STypeCodeStr *type_code_str,
} else {
prev_pos = curr_pos + 1;
curr_pos = strchr(curr_pos + 1, '@');
if (curr_pos)
if (curr_pos) {
read_len++;
}
}
}
get_namespace_and_name_err:
tmp_len = r_list_length(names_l);
if (amount_of_names)
if (amount_of_names) {
*amount_of_names = tmp_len;
}
it = r_list_iterator (names_l);
r_list_foreach_prev (names_l, it, str_info) {
copy_string(type_code_str, str_info->str_ptr, str_info->len);
if (--tmp_len)
if (--tmp_len) {
copy_string(type_code_str, "::", 0);
}
free(str_info);
}
r_list_free(names_l);
@ -513,12 +516,12 @@ DEF_STATE_ACTION(_)
break;
switch(*(state->buff_for_parsing)) {
PROCESS_CASE(J, "long long(__int64)")
PROCESS_CASE(K, "unsigned long long(unsigned __int64)")
PROCESS_CASE(T, "long double(80 bit precision)")
PROCESS_CASE(Z, "long double(64 bit precision)")
PROCESS_CASE(W, "wchar_t")
PROCESS_CASE(N, "bool")
PROCESS_CASE (J, "long long(__int64)")
PROCESS_CASE (K, "unsigned long long(unsigned __int64)")
PROCESS_CASE (T, "long double(80 bit precision)")
PROCESS_CASE (Z, "long double(64 bit precision)")
PROCESS_CASE (W, "wchar_t")
PROCESS_CASE (N, "bool")
default:
state->err = eTCStateMachineErrUncorrectTypeCode;
break;
@ -535,9 +538,9 @@ DEF_STATE_ACTION(_)
// +2 -> skipp @@ ( the end of class, union,...
// or +2 -> skip abbreviated_num + '@'
#define GET_USER_DEF_TYPE_NAME(data_struct_str) { \
copy_string(type_code_str, data_struct_str, 0); \
copy_string (type_code_str, data_struct_str, 0); \
\
check_len = get_namespace_and_name(state->buff_for_parsing, type_code_str, 0); \
check_len = get_namespace_and_name (state->buff_for_parsing, type_code_str, 0); \
if (check_len) { \
state->amount_of_read_chars += check_len + 1; \
state->buff_for_parsing += check_len + 1; \
@ -550,30 +553,30 @@ DEF_STATE_ACTION(_)
DEF_STATE_ACTION(T)
{
#define PROCESS_CASE(case_string, type_str) { \
check_len = strlen(case_string); \
check_len = strlen (case_string); \
if ((check_len < buff_len) && \
(strncmp(state->buff_for_parsing, case_string, check_len) == 0)) { \
copy_string(type_code_str, type_str, 0); \
(strncmp (state->buff_for_parsing, case_string, check_len) == 0)) { \
copy_string (type_code_str, type_str, 0); \
state->buff_for_parsing += check_len; \
state->amount_of_read_chars += check_len; \
return; \
} \
}
int buff_len = strlen(state->buff_for_parsing);
int buff_len = strlen (state->buff_for_parsing);
int check_len = 0;
state->state = eTCStateEnd;
PROCESS_CASE("__m64@@", "__m64");
PROCESS_CASE("__m128@@", "__m128");
PROCESS_CASE("__m128i@@", "__m128i");
PROCESS_CASE("__m256@@", "__m256");
PROCESS_CASE("__m256i@@", "__m256i");
PROCESS_CASE("__m512@@", "__m512");
PROCESS_CASE("__m512i@@", "__m512i");
PROCESS_CASE ("__m64@@", "__m64");
PROCESS_CASE ("__m128@@", "__m128");
PROCESS_CASE ("__m128i@@", "__m128i");
PROCESS_CASE ("__m256@@", "__m256");
PROCESS_CASE ("__m256i@@", "__m256i");
PROCESS_CASE ("__m512@@", "__m512");
PROCESS_CASE ("__m512i@@", "__m512i");
GET_USER_DEF_TYPE_NAME("union ");
GET_USER_DEF_TYPE_NAME ("union ");
#undef PROCESS_CASE
}
@ -581,26 +584,26 @@ DEF_STATE_ACTION(T)
DEF_STATE_ACTION(U)
{
#define PROCESS_CASE(case_string, type_str) { \
check_len = strlen(case_string); \
check_len = strlen (case_string); \
if ((check_len < buff_len) && \
(strncmp(state->buff_for_parsing, case_string, check_len) == 0)) { \
copy_string(type_code_str, type_str, 0); \
(strncmp (state->buff_for_parsing, case_string, check_len) == 0)) { \
copy_string (type_code_str, type_str, 0); \
state->amount_of_read_chars += check_len; \
state->buff_for_parsing += check_len; \
return; \
} \
}
int buff_len = strlen(state->buff_for_parsing);
int buff_len = strlen (state->buff_for_parsing);
int check_len = 0;
state->state = eTCStateEnd;
PROCESS_CASE("__m128d@@", "__m128d");
PROCESS_CASE("__m256d@@", "__m256d");
PROCESS_CASE("__m512d@@", "__m512d");
PROCESS_CASE ("__m128d@@", "__m128d");
PROCESS_CASE ("__m256d@@", "__m256d");
PROCESS_CASE ("__m512d@@", "__m512d");
GET_USER_DEF_TYPE_NAME("struct ");
GET_USER_DEF_TYPE_NAME ("struct ");
#undef PROCESS_CASE
}
@ -636,13 +639,13 @@ char* get_num(SStateInfo *state)
{
char *ptr = 0;
if (*state->buff_for_parsing >= '0' && *state->buff_for_parsing <= '8') {
ptr = (char *) malloc(2);
ptr = (char *) malloc (2);
ptr[0] = *state->buff_for_parsing + 1;
ptr[1] = '\0';
state->buff_for_parsing++;
state->amount_of_read_chars++;
} else if (*state->buff_for_parsing == '9') {
ptr = (char *) malloc(3);
ptr = (char *) malloc (3);
ptr[0] = '1';
ptr[1] = '0';
ptr[2] = '\0';
@ -661,8 +664,8 @@ char* get_num(SStateInfo *state)
if (*state->buff_for_parsing != '@')
return ptr;
ptr = (char *)malloc(16);
sprintf(ptr, "%u", ret);
ptr = (char *)malloc (16);
sprintf (ptr, "%u", ret);
state->buff_for_parsing++;
state->amount_of_read_chars++;
}
@ -680,11 +683,11 @@ char* get_num(SStateInfo *state)
\
state->state = eTCStateEnd; \
\
if (!init_type_code_str_struct(&tmp_str)) { \
if (!init_type_code_str_struct (&tmp_str)) { \
state->err = eTCStateMachineErrAlloc; \
return; \
} \
if (!init_type_code_str_struct(&modifier)) { \
if (!init_type_code_str_struct (&modifier)) { \
state->err = eTCStateMachineErrAlloc; \
return; \
} \
@ -699,13 +702,13 @@ char* get_num(SStateInfo *state)
case 'A': \
break; \
case 'B': \
copy_string(&modifier, "const ", 0); \
copy_string (&modifier, "const ", 0); \
break; \
case 'C': \
copy_string(&modifier, "volatile ", 0); \
copy_string (&modifier, "volatile ", 0); \
break; \
case 'D': \
copy_string(&modifier, "const volatile ", 0); \
copy_string (&modifier, "const volatile ", 0); \
break; \
default: \
state->err = eTCStateMachineErrUnsupportedTypeCode; \
@ -720,37 +723,37 @@ char* get_num(SStateInfo *state)
\
state->buff_for_parsing++; \
state->amount_of_read_chars++; \
if (!(n1 = get_num(state))) { \
if (!(n1 = get_num (state))) { \
goto MODIFIER_err; \
} \
num = atoi(n1); \
R_FREE(n1); \
num = atoi (n1); \
R_FREE (n1); \
\
copy_string(&tmp_str, " ", 0); \
copy_string(&tmp_str, "(", 0); \
copy_string(&tmp_str, modifier.type_str, modifier.curr_pos); \
copy_string(&tmp_str, modifier_str, 0); \
copy_string(&tmp_str, ")", 0); \
copy_string (&tmp_str, " ", 0); \
copy_string (&tmp_str, "(", 0); \
copy_string (&tmp_str, modifier.type_str, modifier.curr_pos); \
copy_string (&tmp_str, modifier_str, 0); \
copy_string (&tmp_str, ")", 0); \
\
while (num--) { \
n1 = get_num(state); \
copy_string(&tmp_str, "[", 0); \
copy_string(&tmp_str, n1, 0); \
copy_string(&tmp_str, "]", 0); \
R_FREE(n1); \
n1 = get_num (state); \
copy_string (&tmp_str, "[", 0); \
copy_string (&tmp_str, n1, 0); \
copy_string (&tmp_str, "]", 0); \
R_FREE (n1); \
} \
} \
\
if (tmp_str.curr_pos == 0) { \
copy_string(&tmp_str, " ", 0); \
copy_string(&tmp_str, modifier.type_str, modifier.curr_pos); \
copy_string(&tmp_str, modifier_str, 0); \
copy_string (&tmp_str, " ", 0); \
copy_string (&tmp_str, modifier.type_str, modifier.curr_pos); \
copy_string (&tmp_str, modifier_str, 0); \
if (flag__64ptr) { \
copy_string(&tmp_str, " __ptr64", 0); \
copy_string (&tmp_str, " __ptr64", 0); \
} \
} \
\
err = get_type_code_string(state->buff_for_parsing, &i, &tmp); \
err = get_type_code_string (state->buff_for_parsing, &i, &tmp); \
if (err != eDemanglerErrOK) { \
state->err = eTCStateMachineErrUnsupportedTypeCode; \
goto MODIFIER_err; \
@ -758,26 +761,26 @@ char* get_num(SStateInfo *state)
\
state->amount_of_read_chars += i; \
state->buff_for_parsing += i; \
copy_string(type_code_str, tmp, 0); \
copy_string(type_code_str, tmp_str.type_str, tmp_str.curr_pos); \
copy_string (type_code_str, tmp, 0); \
copy_string (type_code_str, tmp_str.type_str, tmp_str.curr_pos); \
\
MODIFIER_err: \
R_FREE(tmp); \
free_type_code_str_struct(&tmp_str); \
free_type_code_str_struct(&modifier); \
R_FREE (tmp); \
free_type_code_str_struct (&tmp_str); \
free_type_code_str_struct (&modifier); \
}
///////////////////////////////////////////////////////////////////////////////
DEF_STATE_ACTION(S)
{
MODIFIER("* const volatile");
MODIFIER ("* const volatile");
}
///////////////////////////////////////////////////////////////////////////////
DEF_STATE_ACTION(P)
{
// function pointer
if (isdigit((int)*state->buff_for_parsing)) {
if (isdigit ((int)*state->buff_for_parsing)) {
if (*state->buff_for_parsing++ == '6') {
char *call_conv = 0;
char *ret_type = 0;
@ -810,21 +813,21 @@ DEF_STATE_ACTION(P)
state->amount_of_read_chars += 2; // '6' + call_conv
// return type
err = get_type_code_string(state->buff_for_parsing, &i, &ret_type);
err = get_type_code_string (state->buff_for_parsing, &i, &ret_type);
if (err != eDemanglerErrOK) {
state->err = eTCStateMachineErrUnsupportedTypeCode;
goto FUNCTION_POINTER_err;
}
copy_string(type_code_str, ret_type, 0);
copy_string(type_code_str, " (", 0);
R_FREE(ret_type);
copy_string (type_code_str, ret_type, 0);
copy_string (type_code_str, " (", 0);
R_FREE (ret_type);
if (call_conv) {
copy_string(type_code_str, call_conv, 0);
copy_string (type_code_str, call_conv, 0);
}
copy_string(type_code_str, "*)(", 0);
copy_string (type_code_str, "*)(", 0);
state->amount_of_read_chars += i;
state->buff_for_parsing += i;
@ -834,15 +837,15 @@ DEF_STATE_ACTION(P)
while (*state->buff_for_parsing && *state->buff_for_parsing != 'Z') {
if (*state->buff_for_parsing != '@') {
if (i) {
copy_string(type_code_str, ", ", 0);
copy_string (type_code_str, ", ", 0);
}
err = get_type_code_string(state->buff_for_parsing, &i, &arg);
err = get_type_code_string (state->buff_for_parsing, &i, &arg);
if (err != eDemanglerErrOK) {
// abbreviation of type processing
if ((*state->buff_for_parsing >= '0') && (*state->buff_for_parsing <= '9')) {
ut32 id = (ut32)(*state->buff_for_parsing - '0');
arg = r_list_get_n(abbr_types, id);
arg = r_list_get_n (abbr_types, id);
if (!arg) {
state->err = eTCStateMachineErrUncorrectTypeCode;
goto FUNCTION_POINTER_err;
@ -856,13 +859,13 @@ DEF_STATE_ACTION(P)
}
if (i > 1) {
r_list_append(abbr_types, strdup(arg));
r_list_append (abbr_types, strdup (arg));
}
copy_string(type_code_str, arg, 0);
copy_string (type_code_str, arg, 0);
if (!is_abbr_type) {
R_FREE(arg);
R_FREE (arg);
is_abbr_type = 0;
}
@ -873,7 +876,7 @@ DEF_STATE_ACTION(P)
state->amount_of_read_chars++;
}
}
copy_string(type_code_str, ")", 0);
copy_string (type_code_str, ")", 0);
while (*state->buff_for_parsing == '@') {
state->buff_for_parsing++;
@ -894,22 +897,22 @@ DEF_STATE_ACTION(P)
}
}
MODIFIER("*");
MODIFIER ("*");
}
///////////////////////////////////////////////////////////////////////////////
DEF_STATE_ACTION(R) {
MODIFIER("* volatile");
MODIFIER ("* volatile");
}
///////////////////////////////////////////////////////////////////////////////
DEF_STATE_ACTION(Q) {
MODIFIER("* const");
MODIFIER ("* const");
}
///////////////////////////////////////////////////////////////////////////////
DEF_STATE_ACTION(A) {
MODIFIER("&");
MODIFIER ("&");
}
#undef MODIFIER
@ -925,30 +928,30 @@ static void tc_state_start(SStateInfo *state, STypeCodeStr *type_code_str) {
break; \
switch (*(state->buff_for_parsing)) {
ONE_LETTER_STATE(X)
ONE_LETTER_STATE(D)
ONE_LETTER_STATE(C)
ONE_LETTER_STATE(E)
ONE_LETTER_STATE(F)
ONE_LETTER_STATE(G)
ONE_LETTER_STATE(H)
ONE_LETTER_STATE(I)
ONE_LETTER_STATE(J)
ONE_LETTER_STATE(K)
ONE_LETTER_STATE(M)
ONE_LETTER_STATE(N)
ONE_LETTER_STATE(Z)
ONE_LETTER_STATE(_)
ONE_LETTER_STATE(T)
ONE_LETTER_STATE(U)
ONE_LETTER_STATE(W)
ONE_LETTER_STATE(V)
ONE_LETTER_STATE(O)
ONE_LETTER_STATE(S)
ONE_LETTER_STATE(P)
ONE_LETTER_STATE(R)
ONE_LETTER_STATE(Q)
ONE_LETTER_STATE(A)
ONE_LETTER_STATE (X)
ONE_LETTER_STATE (D)
ONE_LETTER_STATE (C)
ONE_LETTER_STATE (E)
ONE_LETTER_STATE (F)
ONE_LETTER_STATE (G)
ONE_LETTER_STATE (H)
ONE_LETTER_STATE (I)
ONE_LETTER_STATE (J)
ONE_LETTER_STATE (K)
ONE_LETTER_STATE (M)
ONE_LETTER_STATE (N)
ONE_LETTER_STATE (Z)
ONE_LETTER_STATE (_)
ONE_LETTER_STATE (T)
ONE_LETTER_STATE (U)
ONE_LETTER_STATE (W)
ONE_LETTER_STATE (V)
ONE_LETTER_STATE (O)
ONE_LETTER_STATE (S)
ONE_LETTER_STATE (P)
ONE_LETTER_STATE (R)
ONE_LETTER_STATE (Q)
ONE_LETTER_STATE (A)
default:
eprintf("[uncorrect type] error while parsing type\n");
@ -989,7 +992,7 @@ static int init_type_code_str_struct(STypeCodeStr *type_coder_str) {
}
memset (type_coder_str->type_str, 0, TYPE_STR_LEN * sizeof(char));
type_coder_str->curr_pos = 0; // strlen("unknown type");
type_coder_str->curr_pos = 0; // strlen ("unknown type");
// strncpy(type_coder_str->type_str, "unknown_type", type_coder_str->curr_pos);
return res;
@ -1039,12 +1042,12 @@ static EDemanglerErr get_type_code_string(char *sym, unsigned int *amount_of_rea
}
}
*str_type_code = strdup(type_code_str.type_str);
*str_type_code = strdup (type_code_str.type_str);
*amount_of_read_chars = state.amount_of_read_chars;
get_type_code_string_err:
R_FREE(tmp_sym);
free_type_code_str_struct(&type_code_str);
R_FREE (tmp_sym);
free_type_code_str_struct (&type_code_str);
return err;
}
@ -1110,14 +1113,14 @@ static EDemanglerErr parse_microsoft_mangled_name(char *sym, char **demangled_na
case '3' : // Normal variable
case '4' : // Normal variable
i = 0;
err = get_type_code_string(curr_pos, &i, &tmp);
err = get_type_code_string (curr_pos, &i, &tmp);
if (err != eDemanglerErrOK) {
goto parse_microsoft_mangled_name_err;
}
curr_pos += i;
i = strlen(curr_pos);
i = strlen (curr_pos);
if (!i || i > 2) {
err = eDemanglerErrUncorrectMangledSymbol;
goto parse_microsoft_mangled_name_err;
@ -1139,10 +1142,10 @@ static EDemanglerErr parse_microsoft_mangled_name(char *sym, char **demangled_na
}
switch (*curr_pos) {
SET_STORAGE_CLASS('A', 0);
SET_STORAGE_CLASS('B', "const");
SET_STORAGE_CLASS('C', "volatile");
SET_STORAGE_CLASS('D', "const volatile");
SET_STORAGE_CLASS ('A', 0);
SET_STORAGE_CLASS ('B', "const");
SET_STORAGE_CLASS ('C', "volatile");
SET_STORAGE_CLASS ('D', "const volatile");
default:
err = eDemanglerErrUncorrectMangledSymbol;
goto parse_microsoft_mangled_name_err;
@ -1178,24 +1181,24 @@ static EDemanglerErr parse_microsoft_mangled_name(char *sym, char **demangled_na
break; \
}
/* Functions */
SET_ACCESS_MODIFIER('E', is_implicit_this_pointer, "private virtual");
SET_ACCESS_MODIFIER('F', is_implicit_this_pointer, "private virtual");
SET_ACCESS_MODIFIER('M', is_implicit_this_pointer, "protected virtual");
SET_ACCESS_MODIFIER('N', is_implicit_this_pointer, "protected virtual");
SET_ACCESS_MODIFIER('U', is_implicit_this_pointer, "public virtual");
SET_ACCESS_MODIFIER('V', is_implicit_this_pointer, "public virtual");
SET_ACCESS_MODIFIER('A', is_implicit_this_pointer, "private");
SET_ACCESS_MODIFIER('B', is_implicit_this_pointer, "private");
SET_ACCESS_MODIFIER('I', is_implicit_this_pointer, "protected");
SET_ACCESS_MODIFIER('J', is_implicit_this_pointer, "protected");
SET_ACCESS_MODIFIER('Q', is_implicit_this_pointer, "public");
SET_ACCESS_MODIFIER('R', is_implicit_this_pointer, "public");
SET_ACCESS_MODIFIER('C', is_static, "private: static");
SET_ACCESS_MODIFIER('D', is_static, "private: static");
SET_ACCESS_MODIFIER('K', is_static, "protected: static");
SET_ACCESS_MODIFIER('L', is_static, "protected: static");
SET_ACCESS_MODIFIER('S', is_static, "public: static");
SET_ACCESS_MODIFIER('T', is_static, "public: static");
SET_ACCESS_MODIFIER ('E', is_implicit_this_pointer, "private virtual");
SET_ACCESS_MODIFIER ('F', is_implicit_this_pointer, "private virtual");
SET_ACCESS_MODIFIER ('M', is_implicit_this_pointer, "protected virtual");
SET_ACCESS_MODIFIER ('N', is_implicit_this_pointer, "protected virtual");
SET_ACCESS_MODIFIER ('U', is_implicit_this_pointer, "public virtual");
SET_ACCESS_MODIFIER ('V', is_implicit_this_pointer, "public virtual");
SET_ACCESS_MODIFIER ('A', is_implicit_this_pointer, "private");
SET_ACCESS_MODIFIER ('B', is_implicit_this_pointer, "private");
SET_ACCESS_MODIFIER ('I', is_implicit_this_pointer, "protected");
SET_ACCESS_MODIFIER ('J', is_implicit_this_pointer, "protected");
SET_ACCESS_MODIFIER ('Q', is_implicit_this_pointer, "public");
SET_ACCESS_MODIFIER ('R', is_implicit_this_pointer, "public");
SET_ACCESS_MODIFIER ('C', is_static, "private: static");
SET_ACCESS_MODIFIER ('D', is_static, "private: static");
SET_ACCESS_MODIFIER ('K', is_static, "protected: static");
SET_ACCESS_MODIFIER ('L', is_static, "protected: static");
SET_ACCESS_MODIFIER ('S', is_static, "public: static");
SET_ACCESS_MODIFIER ('T', is_static, "public: static");
case 'Y' : // near
case 'Z' : // far
break;
@ -1279,12 +1282,12 @@ static EDemanglerErr parse_microsoft_mangled_name(char *sym, char **demangled_na
// Return type, or @ if 'void'
if (*curr_pos == '@') {
ret_type = strdup("void");
ret_type = strdup ("void");
curr_pos++;
}
else {
i = 0;
err = get_type_code_string(curr_pos, &i, &ret_type);
err = get_type_code_string (curr_pos, &i, &ret_type);
if (err != eDemanglerErrOK) {
err = eDemanglerErrUncorrectMangledSymbol;
goto parse_microsoft_mangled_name_err;
@ -1299,11 +1302,11 @@ static EDemanglerErr parse_microsoft_mangled_name(char *sym, char **demangled_na
while (*curr_pos && *curr_pos != 'Z')
{
if (*curr_pos != '@') {
err = get_type_code_string(curr_pos, &i, &tmp);
err = get_type_code_string (curr_pos, &i, &tmp);
if (err != eDemanglerErrOK) {
// abbreviation of type processing
if ((*curr_pos >= '0') && (*curr_pos <= '9')) {
tmp = r_list_get_n(abbr_types, (ut32)(*curr_pos - '0'));
tmp = r_list_get_n (abbr_types, (ut32)(*curr_pos - '0'));
if (!tmp) {
err = eDemanglerErrUncorrectMangledSymbol;
goto parse_microsoft_mangled_name_err;
@ -1318,25 +1321,25 @@ static EDemanglerErr parse_microsoft_mangled_name(char *sym, char **demangled_na
curr_pos += i;
if (i > 1) {
r_list_append(abbr_types, strdup(tmp));
r_list_append (abbr_types, strdup (tmp));
}
str_arg = (SStrInfo *) malloc(sizeof(SStrInfo));
str_arg->str_ptr = strdup(tmp);
str_arg->len = strlen(tmp);
str_arg = (SStrInfo *) malloc (sizeof(SStrInfo));
str_arg->str_ptr = strdup (tmp);
str_arg->len = strlen (tmp);
r_list_append(func_args, str_arg);
r_list_append (func_args, str_arg);
if (strncmp(tmp, "void", 4) == 0) {
if (strncmp (tmp, "void", 4) == 0) {
// arguments list is void
if (!is_abbr_type) {
R_FREE(tmp);
R_FREE (tmp);
is_abbr_type = 0;
}
break;
}
if (!is_abbr_type) {
R_FREE(tmp);
R_FREE (tmp);
is_abbr_type = 0;
}
} else {
@ -1353,22 +1356,22 @@ static EDemanglerErr parse_microsoft_mangled_name(char *sym, char **demangled_na
}
if (access_modifier) {
copy_string(&func_str, access_modifier, 0);
if (!strstr(access_modifier, "static")) {
copy_string(&func_str, ": ", 0);
copy_string (&func_str, access_modifier, 0);
if (!strstr (access_modifier, "static")) {
copy_string (&func_str, ": ", 0);
} else {
copy_string(&func_str, " ", 0);
copy_string (&func_str, " ", 0);
}
}
if (storage_class_code_for_ret) {
copy_string(&func_str, storage_class_code_for_ret, 0);
copy_string(&func_str, " ", 0);
copy_string (&func_str, storage_class_code_for_ret, 0);
copy_string (&func_str, " ", 0);
}
if (ret_type) {
copy_string(&func_str, ret_type, 0);
copy_string(&func_str, " ", 0);
copy_string (&func_str, ret_type, 0);
copy_string (&func_str, " ", 0);
}
if (call_conv) {
@ -1380,12 +1383,12 @@ static EDemanglerErr parse_microsoft_mangled_name(char *sym, char **demangled_na
copy_string (&func_str, type_code_str.type_str, type_code_str.curr_pos);
}
if (r_list_length(func_args)) {
copy_string(&func_str, "(", 0);
i = r_list_length(func_args);
if (r_list_length (func_args)) {
copy_string (&func_str, "(", 0);
i = r_list_length (func_args);
it = r_list_iterator (func_args);
r_list_foreach (func_args, it, str_arg) {
copy_string(&func_str, str_arg->str_ptr, 0);
copy_string (&func_str, str_arg->str_ptr, 0);
if (--i) {
copy_string (&func_str, ", ", 0);
}
@ -1404,10 +1407,10 @@ static EDemanglerErr parse_microsoft_mangled_name(char *sym, char **demangled_na
*demangled_name = strdup (func_str.type_str);
parse_microsoft_mangled_name_err:
R_FREE(ret_type);
free_type_code_str_struct(&type_code_str);
free_type_code_str_struct(&func_str);
r_list_free(func_args);
R_FREE (ret_type);
free_type_code_str_struct (&type_code_str);
free_type_code_str_struct (&func_str);
r_list_free (func_args);
return err;
}

4
libr/bin/p/bin_coff.c
View File

@ -110,8 +110,8 @@ static RList *entries(RBinFile *arch) {
if (!(ret = r_list_newf (free))) {
return NULL;
}
ptr = r_coff_get_entry(obj);
r_list_append(ret, ptr);
ptr = r_coff_get_entry (obj);
r_list_append (ret, ptr);
return ret;
}

2
libr/bin/p/bin_dex.c
View File

@ -348,7 +348,7 @@ static void dex_parse_debug_item(RBinFile *binfile, RBinDexObj *bin,
struct dex_debug_local_t *debug_locals = calloc (sizeof (struct dex_debug_local_t), regsz + 1);
if (!(MA & 0x0008)) {
debug_locals[argReg].name = "this";
debug_locals[argReg].descriptor = r_str_newf("%s;", class_name);
debug_locals[argReg].descriptor = r_str_newf ("%s;", class_name);
debug_locals[argReg].startAddress = 0;
debug_locals[argReg].signature = NULL;
debug_locals[argReg].live = true;

2
libr/bin/pdb/fpo.c
View File

@ -56,7 +56,7 @@ void parse_fpo_stream(void *stream, R_STREAM_FILE *stream_file)
break;
}
r_list_append(fpo_stream->fpo_data_list, fpo_data);
r_list_append (fpo_stream->fpo_data_list, fpo_data);
}
free(data);

34
libr/bin/pdb/stream_pe.c
View File

@ -12,24 +12,28 @@ void parse_pe_stream(void *stream, R_STREAM_FILE *stream_file)
SPEStream *pe_stream = (SPEStream *) stream;
int sctn_header_size =0;
stream_file_get_size(stream_file, &data_size);
data = (char *) malloc(data_size);
if (!data) return;
stream_file_get_data(stream_file, data);
stream_file_get_size (stream_file, &data_size);
data = (char *) malloc (data_size);
if (!data) {
return;
}
stream_file_get_data (stream_file, data);
sctn_header_size = sizeof(SIMAGE_SECTION_HEADER);
sctn_header_size = sizeof (SIMAGE_SECTION_HEADER);
ptmp = data;
pe_stream->sections_hdrs = r_list_new();
pe_stream->sections_hdrs = r_list_new ();
while (read_bytes < data_size) {
sctn_header = (SIMAGE_SECTION_HEADER *) malloc (sctn_header_size);
if (!sctn_header) break;
memcpy(sctn_header, ptmp, sctn_header_size);
if (!sctn_header) {
break;
}
memcpy (sctn_header, ptmp, sctn_header_size);
ptmp += sctn_header_size;
r_list_append(pe_stream->sections_hdrs, sctn_header);
r_list_append (pe_stream->sections_hdrs, sctn_header);
read_bytes += sctn_header_size;
}
free(data);
free (data);
}
///////////////////////////////////////////////////////////////////////////////
@ -39,10 +43,10 @@ void free_pe_stream(void *stream)
SIMAGE_SECTION_HEADER *sctn_header = 0;
RListIter *it = 0;
it = r_list_iterator(pe_stream->sections_hdrs);
while (r_list_iter_next(it)) {
sctn_header = (SIMAGE_SECTION_HEADER *) r_list_iter_get(it);
free(sctn_header);
it = r_list_iterator (pe_stream->sections_hdrs);
while (r_list_iter_next (it)) {
sctn_header = (SIMAGE_SECTION_HEADER *) r_list_iter_get (it);
free (sctn_header);
}
r_list_free(pe_stream->sections_hdrs);
r_list_free (pe_stream->sections_hdrs);
}

2
libr/cons/less.c
View File

@ -27,7 +27,7 @@ static void color_line(const char *line, RStrpool *p, RList *ml){
m_addr = r_str_ndup (line + m->rm_so, m_len);
if (m_addr) {
/* in case there's a CSI in the middle of this match*/
m_len = r_str_ansi_filter(m_addr, NULL, NULL, m_len);
m_len = r_str_ansi_filter (m_addr, NULL, NULL, m_len);
if (m_len<0) m_len = 0;
r_strpool_memcat (p, m_addr, m_len);
r_strpool_memcat (p, inv[1], linv[1]);

4
libr/core/core.c
View File

@ -1533,9 +1533,9 @@ R_API const char *r_core_anal_optype_colorfor(RCore *core, ut64 addr, bool verbo
static void r_core_setenv (RCore *core) {
char *e = r_sys_getenv ("PATH");
#if __WINDOWS__ && !__CYGWIN__
char *h = r_str_home(".config\\radare2\\prefix\\bin;");
char *h = r_str_home (".config\\radare2\\prefix\\bin;");
#else
char *h = r_str_home(".config/radare2/prefix/bin:");
char *h = r_str_home (".config/radare2/prefix/bin:");
#endif
char *n = r_str_newf ("%s%s", h, e);
r_sys_setenv ("PATH", n);

2
libr/lang/p/lib.c
View File

@ -18,7 +18,7 @@ static int lang_lib_file_run (RLang *user, const char *file) {
libpath = r_str_prefix (libpath, "./");
}
if (!r_file_exists (libpath)) {
if (!r_str_endswith(libpath, R_LIB_EXT)) {
if (!r_str_endswith (libpath, R_LIB_EXT)) {
libpath = r_str_appendf (libpath, ".%s", R_LIB_EXT);
}
}

2
libr/parse/p/parse_mips_pseudo.c
View File

@ -201,7 +201,7 @@ static int parse(RParse *p, const char *data, char *str) {
{
char *p = strdup (str);
p = r_str_replace (p, "+ -", "- ", 0);
p = r_str_replace(p, " + ]", " + 0]", 0);
p = r_str_replace (p, " + ]", " + 0]", 0);
#if EXPERIMENTAL_ZERO
p = r_str_replace (p, "zero", "0", 0);
if (!memcmp (p, "0 = ", 4)) *p = 0; // nop

4
libr/util/strpool.c
View File

@ -66,12 +66,12 @@ R_API int r_strpool_memcat(RStrpool *p, const char *s, int len) {
R_API int r_strpool_append(RStrpool *p, const char *s) {
int l = strlen (s) + 1;
return r_strpool_memcat(p, s, l);
return r_strpool_memcat (p, s, l);
}
R_API int r_strpool_ansi_chop(RStrpool *p, int n){
/* p->str need not be a c-string */
int i = r_str_ansi_chop(p->str, p->len, n);
int i = r_str_ansi_chop (p->str, p->len, n);
p->len = i;
return i;
}