From 80d4b44b2ea53a418e40895a0ff704a9f6027fc8 Mon Sep 17 00:00:00 2001 From: Marc Date: Wed, 12 Jul 2017 17:07:47 +0200 Subject: [PATCH] Fix random code style issues --- binr/rafind2/rafind2.c | 2 +- libr/anal/sign.c | 2 +- libr/asm/arch/arm/winedbg/be_arm.c | 480 ++++++++++++++----------- libr/bin/dwarf.c | 206 ++++++----- libr/bin/mangling/microsoft_demangle.c | 429 +++++++++++----------- libr/bin/p/bin_coff.c | 4 +- libr/bin/p/bin_dex.c | 2 +- libr/bin/pdb/fpo.c | 2 +- libr/bin/pdb/stream_pe.c | 34 +- libr/cons/less.c | 2 +- libr/core/core.c | 4 +- libr/lang/p/lib.c | 2 +- libr/parse/p/parse_mips_pseudo.c | 2 +- libr/util/strpool.c | 4 +- 14 files changed, 652 insertions(+), 523 deletions(-) diff --git a/binr/rafind2/rafind2.c b/binr/rafind2/rafind2.c index 4f54ce1c48..fed06c0a58 100644 --- a/binr/rafind2/rafind2.c +++ b/binr/rafind2/rafind2.c @@ -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); diff --git a/libr/anal/sign.c b/libr/anal/sign.c index 670a3acee0..4f25622f4b 100644 --- a/libr/anal/sign.c +++ b/libr/anal/sign.c @@ -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); diff --git a/libr/asm/arch/arm/winedbg/be_arm.c b/libr/asm/arch/arm/winedbg/be_arm.c index bcbf8044e3..9ffa342243 100644 --- a/libr/asm/arch/arm/winedbg/be_arm.c +++ b/libr/asm/arch/arm/winedbg/be_arm.c @@ -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; diff --git a/libr/bin/dwarf.c b/libr/bin/dwarf.c index f05300297c..f2b5447dde 100644 --- a/libr/bin/dwarf.c +++ b/libr/bin/dwarf.c @@ -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; diff --git a/libr/bin/mangling/microsoft_demangle.c b/libr/bin/mangling/microsoft_demangle.c index 519b345236..a936193102 100644 --- a/libr/bin/mangling/microsoft_demangle.c +++ b/libr/bin/mangling/microsoft_demangle.c @@ -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; } diff --git a/libr/bin/p/bin_coff.c b/libr/bin/p/bin_coff.c index 123c9b4fa0..b6d2660eee 100644 --- a/libr/bin/p/bin_coff.c +++ b/libr/bin/p/bin_coff.c @@ -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; } diff --git a/libr/bin/p/bin_dex.c b/libr/bin/p/bin_dex.c index fb63dd70b5..57c6d09386 100644 --- a/libr/bin/p/bin_dex.c +++ b/libr/bin/p/bin_dex.c @@ -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; diff --git a/libr/bin/pdb/fpo.c b/libr/bin/pdb/fpo.c index 54ab96f90e..e9fe58fb7b 100644 --- a/libr/bin/pdb/fpo.c +++ b/libr/bin/pdb/fpo.c @@ -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); diff --git a/libr/bin/pdb/stream_pe.c b/libr/bin/pdb/stream_pe.c index 5e4cf2467d..aa058994b3 100644 --- a/libr/bin/pdb/stream_pe.c +++ b/libr/bin/pdb/stream_pe.c @@ -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); } diff --git a/libr/cons/less.c b/libr/cons/less.c index 7cb27355de..60a1f859c8 100644 --- a/libr/cons/less.c +++ b/libr/cons/less.c @@ -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]); diff --git a/libr/core/core.c b/libr/core/core.c index e9ec872347..c75bc3955a 100644 --- a/libr/core/core.c +++ b/libr/core/core.c @@ -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); diff --git a/libr/lang/p/lib.c b/libr/lang/p/lib.c index 376c8a200d..5d66981781 100644 --- a/libr/lang/p/lib.c +++ b/libr/lang/p/lib.c @@ -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); } } diff --git a/libr/parse/p/parse_mips_pseudo.c b/libr/parse/p/parse_mips_pseudo.c index 2923a650f0..2c4fa09f4d 100644 --- a/libr/parse/p/parse_mips_pseudo.c +++ b/libr/parse/p/parse_mips_pseudo.c @@ -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 diff --git a/libr/util/strpool.c b/libr/util/strpool.c index 58b38a8c87..89c62a3bf2 100644 --- a/libr/util/strpool.c +++ b/libr/util/strpool.c @@ -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; }