search

rizinorg / rizin

UNIX-like reverse engineering framework and command-line toolset.
https://rizin.re
GNU Lesser General Public License v3.0
2.59k stars 346 forks source link

Remove `sdb_fmt` and switch to `rz_strf`/`rz_str_*`/`rz_strbuf_` API depending on the case #1168

Closed XVilka closed 6 months ago

XVilka commented 3 years ago

Currently Rizin uses sdb_fmt function, which uses global state and is thread-unsafe. I suggest substituting all calls of it with the Rizin API like:

librz/util/table.c
1150:                                   sdb_fmt("%d%c", i, rz_itv_contain(info->vitv, seek) ? '*' : ' '),
1151:                                   sdb_fmt("0x%" PFMT64x, info->vitv.addr),
1153:                                   sdb_fmt("0x%" PFMT64x, rz_itv_end(info->vitv)),
1158:                           rz_table_add_rowf(table, "sssssss", sdb_fmt("%d%c", i, rz_itv_contain(info->pitv, seek) ? '*' : ' '),
1159:                                   sdb_fmt("0x%" PFMT64x, info->pitv.addr), b,
1160:                                   sdb_fmt("0x%" PFMT64x, rz_itv_end(info->pitv)),
1175:                   rz_table_add_rowf(table, "sssssss", "=>", sdb_fmt("0x%08" PFMT64x, seek),
1176:                           rz_strbuf_drain(buf), sdb_fmt("0x%08" PFMT64x, seek + len), "", "", "");

librz/syscall/syscall.c
218:            key = sdb_fmt("%d.%d", swi, num);
220:            key = sdb_fmt("0x%02x.%d", swi, num);
224:            key = sdb_fmt("0x%02x.0x%02x", swi, num); // Workaround until Syscall SDB is fixed
227:                    key = sdb_fmt("0x%02x.%d", num, swi); // Workaround until Syscall SDB is fixed
311:    const char *key = sdb_fmt("%s,%" PFMT64d, type, num);

librz/debug/trace.c
204:            sdb_fmt("trace.%d.%" PFMT64x, tag, addr), NULL);
296:            sdb_fmt("trace.%d.%" PFMT64x, tag, addr), tp);

librz/io/p/io_winedbg.c
319:            free(runcmd(sdb_fmt("break *%x", rz_num_get(NULL, cmd + 3) || io->off)));

librz/core/project.c
35:     sdb_set(prj, RZ_PROJECT_KEY_VERSION, sdb_fmt("%u", RZ_PROJECT_VERSION), 0);

librz/core/rtr.c
908:            if (!rz_socket_connect(s, rh->host, sdb_fmt("%d", rh->port), RZ_SOCKET_PROTO_TCP, 0)) {

librz/core/cmd_debug.c
2150:                   // sdb_fmt is not thread safe
2152:                           sdb_fmt("%d", e->offset),
2153:                           sdb_fmt("%d", e->size),
2154:                           sdb_fmt("%d", e->packed_size),
2155:                           sdb_fmt("%d", e->index),
2156:                           sdb_fmt("%d", i),
5136:                           rz_core_cmd0(core, sdb_fmt("oodf %s", input + 3));
5265:                           str = rz_core_cmd_str(core, sdb_fmt("gs %s", input + 2));

librz/core/agraph.c
255:    const char *shortcut = sdb_const_get(g->db, sdb_fmt("agraph.nodes.%s.shortcut", nodetitle), 0);
259:                    strncat(title, sdb_fmt(Color_YELLOW "[o%s]" Color_RESET, shortcut), left);
261:                    strncat(title, sdb_fmt("[o%s]", shortcut), left);
2254:                           sdb_set(g->db, sdb_fmt("agraph.nodes.%s.shortcut", title), shortcut, 0);
2386:                           sdb_set(g->db, sdb_fmt("agraph.nodes.%s.shortcut", title), shortcut, 0);
2731:           k = sdb_fmt("agraph.nodes.%s.x", a->title);
2733:           k = sdb_fmt("agraph.nodes.%s.y", a->title);
2735:           k = sdb_fmt("agraph.nodes.%s.w", a->title);
2737:           k = sdb_fmt("agraph.nodes.%s.h", a->title);
3214:#define K_NEIGHBOURS(x) (sdb_fmt("agraph.nodes.%s.neighbours", x->title))
3761:           //s = sdb_fmt ("base64:%s", estr);
3765:           sdb_set_owned(g->db, sdb_fmt("agraph.nodes.%s.body", res->title), s, 0);
3785:   sdb_set(g->db, sdb_fmt("agraph.nodes.%s", res->title), NULL, 0);
3786:   sdb_set(g->db, sdb_fmt("agraph.nodes.%s.body", res->title), 0, 0);
3787:   sdb_set(g->db, sdb_fmt("agraph.nodes.%s.x", res->title), NULL, 0);
3788:   sdb_set(g->db, sdb_fmt("agraph.nodes.%s.y", res->title), NULL, 0);
3789:   sdb_set(g->db, sdb_fmt("agraph.nodes.%s.w", res->title), NULL, 0);
3790:   sdb_set(g->db, sdb_fmt("agraph.nodes.%s.h", res->title), NULL, 0);
3791:   sdb_set(g->db, sdb_fmt("agraph.nodes.%s.neighbours", res->title), NULL, 0);
3795:           const char *key = sdb_fmt("agraph.nodes.%s.neighbours", an->title);
3871:           char *k = sdb_fmt("agraph.nodes.%s.neighbours", a->title);
3879:           char *k = sdb_fmt("agraph.nodes.%s.neighbours", a->title);
3888:           const char *k = sdb_fmt("agraph.nodes.%s.neighbours", a->title);

librz/core/vmenus.c
3201:                   char *newname = rz_cons_input(sdb_fmt("New variable name for '%s': ", var->name));
3463:                   char *newname = rz_cons_input(sdb_fmt("New variable name for '%s': ", var->name));

librz/core/disasm.c
2526:                           rz_asm_op_set_asm(&ds->asmop, sdb_fmt(".string \"%s%s\"", meta->str, tail));
2530:                           rz_asm_op_set_asm(&ds->asmop, sdb_fmt(".hex %s%s", op_hex, tail));

librz/core/cmd_print.c
1969:   int addrpadlen = strlen(sdb_fmt("%08" PFMT64x, addr)) - 8;
3509:                           rz_table_add_rowf(t, "sddddd", sdb_fmt("0x%09" PFMT64x "", at), as->block[p].flags,
5183:                                   cmd_pDj(core, sdb_fmt("%d", core->blocksize));

librz/core/cfile.c
536:            rz_sys_setenv("RZ_SIZE", sdb_fmt("%" PFMT64d, rz_io_desc_size(desc)));
547:    rz_sys_setenv("RZ_OFFSET", sdb_fmt("%" PFMT64d, core->offset));
548:    rz_sys_setenv("RZ_XOFFSET", sdb_fmt("0x%08" PFMT64x, core->offset));
550:    rz_sys_setenv("RZ_BSIZE", sdb_fmt("%d", core->blocksize));
568:    rz_sys_setenv("RZ_BITS", sdb_fmt("%" PFMT64u, rz_config_get_i(core->config, "asm.bits")));
1051:                   RzFlagItem *impsym = rz_flag_get(r->flags, sdb_fmt("sym.imp.%s", imp->name));

librz/core/panels.c
4114:           ht_pp_insert(panels->mht, sdb_fmt("%s.%s", parent, name), item);
4117:           ht_pp_insert(panels->mht, sdb_fmt("%s", name), item);
4152:           ht_pp_delete(core->panels->mht, sdb_fmt("%s.%s", parent, sub->name));

librz/core/cbin.c
532:            sdb_concat_by_path(r->analysis->sdb_fmts, spath);
961:    char *foo = sdb_get(db, sdb_fmt("%d", ordinal), 0);
1055:                           filename = sdb_fmt("%s.sdb", module);
1061:                                   filename = sdb_fmt(RZ_JOIN_4_PATHS("%s", RZ_SDB_FORMAT, "dll", "%s.sdb"),
2370:                   // take care with very long symbol names! do not use sdb_fmt or similar
2564:                           rz_table_add_rowf(table, "nXssss", (ut64)import->ordinal, addr, bind, type, libname ? libname : "", sdb_fmt("%s.%s", import->classname, symname));
3142:                           ? sdb_fmt("%s.%s", r->bin->prefix, section->name)
3818:           char *path_version = sdb_fmt(format_version, num_version);
3827:           const char *path_fixedfileinfo = sdb_fmt("%s/fixed_file_info", path_version);
3930:           const char *versym_path = sdb_fmt(format, "versym", num_versym);
3956:                   const char *const key = sdb_fmt("entry%d", i);
4017:                   char *path_version = sdb_fmt("%s/version%d", verneed_path, num_version);
4047:                           const char *const path_vernaux = sdb_fmt("%s/vernaux%d", path_version, num_vernaux++);
4101:           const char *timestrKey = sdb_fmt("resource.%d.timestr", index);
4102:           const char *vaddrKey = sdb_fmt("resource.%d.vaddr", index);
4103:           const char *sizeKey = sdb_fmt("resource.%d.size", index);
4104:           const char *typeKey = sdb_fmt("resource.%d.type", index);
4105:           const char *languageKey = sdb_fmt("resource.%d.language", index);
4106:           const char *nameKey = sdb_fmt("resource.%d.name", index);
4540:                                   pj_s(pj, sdb_fmt("0x%08" PFMT64x, flag));

librz/core/cmd_info.c
213:                    pair("fd", sdb_fmt("%d", desc->fd));
240:            pair("block", sdb_fmt("0x%x", core->blocksize));

librz/core/cmd_analysis.c
1391:   return sdb_fmt(n > 1000 ? "0x%x" : "%d", n);
3546:                   const char *name = rz_reg_get_name(reg, rz_reg_get_name_idx(sdb_fmt("A%d", i)));
4747:           const char *alias = sdb_fmt("A%d", i);
6132:#define var_ref_list(a, d, t) sdb_fmt("var.0x%" PFMT64x ".%d.%d.%s", \

librz/core/cmd_search.c
519:            const char *flag = sdb_fmt("%s%d_%d", searchprefix, kw->kwidx, kw->count);
1191:                   const char *key = sdb_fmt("0x%08" PFMT64x, addr);
1231:                   const char *key = sdb_fmt("0x%08" PFMT64x, addr);
1285:                   const char *key = sdb_fmt("0x%08" PFMT64x, addr);
2298:                                   const char *flagname = sdb_fmt("%s%d_%d", searchprefix, kwidx, count);

librz/core/cmd_magic.c
130:                    const char *flag = sdb_fmt("%s%d_%d", searchprefix, 0, kw_count++);

librz/core/cmd_help.c
587:                            pj_ks(pj, "int32", sdb_fmt("%d", (st32)(n & UT32_MAX)));
588:                            pj_ks(pj, "uint32", sdb_fmt("%u", (ut32)n));
589:                            pj_ks(pj, "int64", sdb_fmt("%" PFMT64d, (st64)n));
590:                            pj_ks(pj, "uint64", sdb_fmt("%" PFMT64u, (ut64)n));
591:                            pj_ks(pj, "hex", sdb_fmt("0x%08" PFMT64x, n));
592:                            pj_ks(pj, "octal", sdb_fmt("0%" PFMT64o, n));
594:                            pj_ks(pj, "segment", sdb_fmt("%04x:%04x", s, a));
627:                            pj_ks(pj, "fvalue", sdb_fmt("%.1lf", core->num->fvalue));
628:                            pj_ks(pj, "float", sdb_fmt("%ff", f));
629:                            pj_ks(pj, "double", sdb_fmt("%lf", d));
630:                            pj_ks(pj, "binary", sdb_fmt("0b%s", out));
632:                            pj_ks(pj, "trits", sdb_fmt("0t%s", out));

librz/debug/dsession.c
268:    sdb_set(db, sdb_fmt("0x%" PFMT64x, k), pj_string(j), 0);
295:    sdb_set(db, sdb_fmt("0x%" PFMT64x, k), pj_string(j), 0);
363:            sdb_set(db, sdb_fmt("0x%x", chkpt->cnum), pj_string(j), 0);
562:#define SNAPATTR(ATTR) sdb_fmt("snaps.a[%u]." ATTR, i)
563:#define REGATTR(ATTR)  sdb_fmt("registers.%d." ATTR, i)

librz/flag/tags.c
8:      const char *k = sdb_fmt("tag.%s", name);
16:             const char *k = sdb_fmt("tag.%s", name);
61:     const char *k = sdb_fmt("tag.%s", name);

librz/core/cmd_flag.c
488:            const char *addr = sdb_fmt("0x%08" PFMT64x, flag->offset);
489:            rz_table_add_row(t, addr, sdb_fmt("%" PFMT64d, flag->size), spaceName, flag->name, NULL);
559:                    const char *flags = sdb_get(core->flags->tags, sdb_fmt("tag.%s", tag), NULL);

librz/debug/p/debug_io.c
134:    const char *cmd = sdb_fmt("dk %d", sig);

librz/debug/p/debug_windbg.c
452:                                            name = sdb_fmt("%s | %.8s", mod->name, s[i][j].Name);

librz/debug/p/native/windows/windows_debug.c
1136:           rz_io_system(dbg->iob.io, sdb_fmt("pid %d", dbg->tid));

librz/debug/p/native/linux/linux_coredump.c
87:     file = sdb_fmt("/proc/%d/cmdline", mypid);
133:    const char *file = sdb_fmt("/proc/%d/task/%d/stat", pid, tid);
160:    file = sdb_fmt("/proc/%d/task/%d/status", pid, tid);
562:    const char *file = sdb_fmt("/proc/%d/auxv", dbg->pid);
784:    const char *file = sdb_fmt("/proc/%d/stat", dbg->pid);
818:    file = sdb_fmt("/proc/%d/status", dbg->pid);
858:    file = sdb_fmt("/proc/%d/coredump_filter", dbg->pid);

librz/debug/p/debug_native.c
422:                    rz_io_system(dbg->iob.io, sdb_fmt("pid %d", dbg->tid));
1026:           perror(sdb_fmt("Cannot open '%s'", path));

librz/core/canalysis.c
1141:           rz_flag_set(core->flags, sdb_fmt("sym.go.%s", func_name), func_addr, 1);
1147:           oldstr = rz_print_rowlog(core->print, sdb_fmt("Found %d symbols and saved them at sym.go.*", num_syms));
1329:           rz_analysis_function_rename(fcn, sdb_fmt("%s.%08" PFMT64x, fcnpfx, fcn->addr));
2855:                           const char *dst = item ? item->name : sdb_fmt("0x%08" PFMT64x, xref->to);
2876:                   const char *dst = item ? item->name : sdb_fmt("0x%08" PFMT64x, xref->from);
3811:           const char *fcnAddr = sdb_fmt("0x%08" PFMT64x, fcn->addr);
3812:           const char *fcnSize = sdb_fmt("%" PFMT64u, rz_analysis_function_linear_size(fcn));
3813:           const char *nbbs = sdb_fmt("%d", rz_list_length(fcn->bbs)); // rz_analysis_fcn_size (fcn));
3822:           const char *callstr = sdb_fmt("%d", rz_list_length(calls));
4571:           char *key = sdb_fmt("0x%" PFMT64x, xref_to);
4572:           char *value = sdb_fmt("0x%" PFMT64x, at);
5268:           char *flagname = sdb_fmt("str.%s", str_flagname);
5881:                           rz_flag_set_next(core->flags, sdb_fmt("syscall.%s", si->name), cur, 1);
5887:                           rz_flag_set_next(core->flags, sdb_fmt("syscall.%d", snv), cur, 1);
5961:                                                           char *str2 = sdb_fmt("esilref: '%s'", str);
7434:                   oldstr = rz_print_rowlog(core->print, sdb_fmt("from 0x%" PFMT64x " to 0x%" PFMT64x " (aav)", map->itv.addr, rz_itv_end(map->itv)));
7457:                   oldstr = rz_print_rowlog(core->print, sdb_fmt("Value from 0x%08" PFMT64x " to 0x%08" PFMT64x " (aav)", from, to));
7474:                           oldstr = rz_print_rowlog(core->print, sdb_fmt("0x%08" PFMT64x "-0x%08" PFMT64x " in 0x%" PFMT64x "-0x%" PFMT64x " (aav)", from, to, begin, end));

librz/debug/debug.c
620:    rz_io_system(dbg->iob.io, sdb_fmt("pid %d", dbg->tid));

librz/bin/bin.c
180:            return sdb_fmt("%s_%d", s->name, s->dup_count);
970:                    str_fmt = h_flag && strcmp(h_flag, "unknown_flag") ? sdb_fmt("%s_%i %s", arch, bits, h_flag)
971:                                                                       : sdb_fmt("%s_%i", arch, bits);
1002:                           str_fmt = h_flag && strcmp(h_flag, "unknown_flag") ? sdb_fmt("%s_%i %s", arch, bits, h_flag)
1003:                                                                              : sdb_fmt("%s_%i", arch, bits);

librz/analysis/analysis.c
114:    analysis->sdb_fmts = sdb_ns(analysis->sdb, "spec", 1);
270:    const char *dbpath = sdb_fmt(RZ_JOIN_3_PATHS("%s", RZ_SDB_FCNSIGN, "types-%s.sdb"),
439:#define K_NORET_ADDR(x) sdb_fmt("addr.%" PFMT64x ".noreturn", x)
440:#define K_NORET_FUNC(x) sdb_fmt("func.%s.noreturn", x)

librz/analysis/var.c
655:            char *ptr_end = strstr(esil_buf, sdb_fmt(",%s,%s,", reg, sign));

librz/analysis/fcn.c
1726:           const char *cc_arg = rz_reg_get_name(a->reg, rz_reg_get_name_idx(sdb_fmt("A%d", i)));

librz/analysis/esil_trace.c
8:#define KEY(x)               sdb_fmt("%d." x, esil->trace->idx)
9:#define KEYAT(x, y)          sdb_fmt("%d." x ".0x%" PFMT64x, esil->trace->idx, y)
10:#define KEYREG(x, y)         sdb_fmt("%d." x ".%s", esil->trace->idx, y)

librz/bin/bfile.c
22:     const char *name = sdb_fmt("%s::%s", klass, method);
1033:                   const char *name = sdb_fmt("%s::%s", klass, method);

librz/bin/bobj.c
303:            //sdb_ns (sdb, sdb_fmt ("fd.%d", bf->fd), 1);
312:            const char *fdns = sdb_fmt("fd.%d", bf->fd);
367:                            const char *name = sdb_fmt("%s::%s", klass->name, method->name);

librz/bin/filter.c
37:     const char *uname = sdb_fmt("%" PFMT64x ".%s", vaddr, resname);
40:     int count = sdb_num_inc(db, sdb_fmt("%x", hash), 1, 0);
42:     if (sdb_exists(db, sdb_fmt("%x", vhash))) {
46:     sdb_num_set(db, sdb_fmt("%x", vhash), 1, 0);
95:     const char *uname = sdb_fmt("%" PFMT64x ".%c.%s", vaddr, sym->is_imported ? 'i' : 's', name);
102:    const char *oname = sdb_fmt("o.0.%c.%s", sym->is_imported ? 'i' : 's', name);

librz/analysis/cc.c
55:     sdb_set(DB, sdb_fmt("cc.%s.ret", ccname), e, 0);
63:                     sdb_set(DB, sdb_fmt("cc.%s.argn", ccname), arg, 0);
65:                     sdb_set(DB, sdb_fmt("cc.%s.arg%d", ccname, n), arg, 0);
83:     const char *ret = sdb_const_get(DB, sdb_fmt("cc.%s.ret", name), 0);
93:             const char *k = sdb_fmt("cc.%s.arg%d", name, i);
101:    const char *argn = sdb_const_get(DB, sdb_fmt("cc.%s.argn", name), 0);
129:    const char *query = sdb_fmt("cc.%s.arg%d", convention, n);
132:            query = sdb_fmt("cc.%s.argn", convention);
140:    const char *query = sdb_fmt("cc.%s.self", convention);
157:    const char *query = sdb_fmt("cc.%s.error", convention);
184:            const char *query = sdb_fmt("cc.%s.arg%d", cc, i);
196:    char *query = sdb_fmt("cc.%s.ret", convention);

librz/analysis/class.c
23:     return sdb_fmt("attrtypes.%s", name);
27:     return sdb_fmt("attr.%s.%s", class_name, attr_type);
31:     return sdb_fmt("attr.%s.%s.%s", class_name, attr_type, attr_id);
35:     return sdb_fmt("attr.%s.%s.%s.specific", class_name, attr_type, attr_id);
437:    char *r = sdb_fmt("%s.%s.%s", attr_type, class_name, attr_id);
672:    char *content = sdb_fmt("%" PFMT64u "%c%" PFMT64d "%c%" PFMT32u "%c%s", meth->addr, SDB_RS, meth->vtable_offset, SDB_RS, meth->method_type, SDB_RS, meth->real_name);
825:    char *content = sdb_fmt("%s" SDB_SS "%" PFMT64u, base_class_name_sanitized, base->offset);
1017:   char *content = sdb_fmt("0x%" PFMT64x SDB_SS "%" PFMT64u SDB_SS "%" PFMT64u, vtable->addr, vtable->offset, vtable->size);

librz/asm/asm.c
465:                            rz_strbuf_set(&op->buf_asm, sdb_fmt(".word 0x%04x", b));
468:                            rz_strbuf_set(&op->buf_asm, sdb_fmt(".dword 0x%08x", b));

librz/bin/p/bin_art.c
46:     sdb_set(db, "img.base", sdb_fmt("0x%x", art->image_base), 0);
47:     sdb_set(db, "img.size", sdb_fmt("0x%x", art->image_size), 0);
48:     sdb_set(db, "art.checksum", sdb_fmt("0x%x", art->checksum), 0);
49:     sdb_set(db, "art.version", sdb_fmt("%c%c%c", art->version[0], art->version[1], art->version[2]), 0);
50:     sdb_set(db, "oat.begin", sdb_fmt("0x%x", art->oat_file_begin), 0);
51:     sdb_set(db, "oat.end", sdb_fmt("0x%x", art->oat_file_end), 0);
52:     sdb_set(db, "oat_data.begin", sdb_fmt("0x%x", art->oat_data_begin), 0);
53:     sdb_set(db, "oat_data.end", sdb_fmt("0x%x", art->oat_data_end), 0);
54:     sdb_set(db, "patch_delta", sdb_fmt("0x%x", art->patch_delta), 0);
55:     sdb_set(db, "image_roots", sdb_fmt("0x%x", art->image_roots), 0);
56:     sdb_set(db, "compile_pic", sdb_fmt("0x%x", art->compile_pic), 0);

librz/asm/p/asm_arm_cs.c
205:            char *buf_asm = sdb_fmt("%s%s%s",

librz/asm/p/asm_bf.c
56:             buf_asm = sdb_fmt(fmt, buf_asm, rep);

librz/asm/p/asm_m68k_cs.c
106:            buf_asm = sdb_fmt("%s%s%s", insn->mnemonic, insn->op_str[0] ? " " : "", insn->op_str);

librz/asm/p/asm_msp430.c
17:                     rz_strbuf_set(&op->buf_asm, sdb_fmt("%s %s", cmd.instr, cmd.operands));
19:                     rz_strbuf_set(&op->buf_asm, sdb_fmt("%s", cmd.instr));

librz/asm/p/asm_ppc_cs.c
102:            const char *opstr = sdb_fmt("%s%s%s", insn->mnemonic,

librz/asm/p/asm_tms320.c
63:     char *buf_asm = sdb_fmt("%s%s%s", insn->mnemonic, insn->op_str[0] ? " " : "", insn->op_str);

librz/bin/p/bin_elf.inc
1362:   rz_list_append(ret, rz_bin_field_new(addr, addr, siz, nam, sdb_fmt("0x%08" PFMT64x, (ut64)val), fmt, false));

librz/asm/p/asm_x86_vm.c
35:                     buf_asm = sdb_fmt("vpcext $0x%x, $0x%x", buf[3], buf[2]);
37:                     buf_asm = sdb_fmt("vpcext %xh, %xh", buf[2], buf[3]);

librz/asm/p/asm_v850.c
23:             rz_asm_op_set_asm(op, sdb_fmt("%s %s", cmd.instr, cmd.operands));

librz/asm/p/asm_xcore_cs.c
32:     rz_asm_op_set_asm(op, sdb_fmt("%s%s%s", insn->mnemonic, insn->op_str[0] ? " " : "", insn->op_str));

librz/asm/p/asm_tms320c64x.c
51:     rz_asm_op_set_asm(op, sdb_fmt("%s%s%s", insn->mnemonic, insn->op_str[0] ? " " : "", insn->op_str));

librz/asm/p/asm_v810.c
22:             rz_asm_op_set_asm(op, sdb_fmt("%s %s", cmd.instr, cmd.operands));

librz/bin/p/bin_pe64.c
39:     rz_list_append(ret, rz_bin_field_new(addr, addr, siz, nam, sdb_fmt("0x%08" PFMT64x, (ut64)val), fmt, false));

librz/asm/p/asm_x86_cs.c
84:             char *buf_asm = sdb_fmt("%s%s%s",

librz/asm/p/asm_propeller.c
17:             buf_asm = sdb_fmt("%s %s %s", cmd.prefix, cmd.instr, cmd.operands);
19:             buf_asm = sdb_fmt("%s %s", cmd.instr, cmd.operands);
21:             buf_asm = sdb_fmt("%s", cmd.instr);

librz/asm/p/asm_sparc_cs.c
49:     char *buf_asm = sdb_fmt("%s%s%s",

librz/bin/p/bin_xnu_kernelcache.c
1203:           const char *key = sdb_fmt("%" PFMT64x, sym->vaddr);
1213:                   const char *key = sdb_fmt("%" PFMT64x, sym->vaddr);
1224:                   const char *key = sdb_fmt("%" PFMT64x, sym->vaddr);
1587:                           const char *key = sdb_fmt("%d", num);
1675:                   const char *key = sdb_fmt("%" PFMT64x, addr);

librz/asm/p/asm_or1k.c
45:             *line = sdb_fmt("invalid");
51:             *line = sdb_fmt(type_descr->format, name);
54:             *line = sdb_fmt(type_descr->format, name,
59:             *line = sdb_fmt(type_descr->format, name, o.k);
62:             *line = sdb_fmt(type_descr->format, name, o.rd, o.k);
65:             *line = sdb_fmt(type_descr->format, name, o.rd, o.n << 13);
68:             *line = sdb_fmt(type_descr->format, name, o.rb);
71:             *line = sdb_fmt(type_descr->format, name, o.rd);
74:             *line = sdb_fmt(type_descr->format, name, o.ra, o.i);
77:             *line = sdb_fmt(type_descr->format, name, o.rd, o.ra, o.i);
80:             *line = sdb_fmt(type_descr->format, name, o.rd, o.ra, o.i);
83:             *line = sdb_fmt(type_descr->format, name, o.rd, o.ra, o.l);
86:             *line = sdb_fmt(type_descr->format, name, o.rd, o.ra);
89:             *line = sdb_fmt(type_descr->format, name, o.rd, o.ra, o.rb);
92:             *line = sdb_fmt(type_descr->format, name, o.ra, o.rb);
95:             *line = sdb_fmt(type_descr->format, name,
99:             *line = sdb_fmt(type_descr->format, name,
103:            *line = sdb_fmt("invalid");
118:            line = sdb_fmt("invalid");
131:            line = sdb_fmt("invalid");
139:            line = sdb_fmt("invalid");

librz/asm/p/asm_sysz.c
43:                     char *buf_asm = sdb_fmt("%s%s%s",

librz/asm/p/asm_m680x_cs.c
81:                     char *buf_asm = sdb_fmt("%s%s%s",

librz/bin/p/bin_qnx.c
14:     sdb_set(db, "qnx.version", sdb_fmt("0x%xH", lmfh->version), 0);
15:     sdb_set(db, "qnx.cflags", sdb_fmt("0x%xH", lmfh->cflags), 0);
16:     sdb_set(db, "qnx.cpu", sdb_fmt("0x%xH", lmfh->cpu), 0);
17:     sdb_set(db, "qnx.fpu", sdb_fmt("0x%xH", lmfh->fpu), 0);
18:     sdb_set(db, "qnx.code_index", sdb_fmt("0x%x", lmfh->code_index), 0);
19:     sdb_set(db, "qnx.stack_index", sdb_fmt("0x%x", lmfh->stack_index), 0);
20:     sdb_set(db, "qnx.heap_index", sdb_fmt("0x%x", lmfh->heap_index), 0);
21:     sdb_set(db, "qnx.argv_index", sdb_fmt("0x%x", lmfh->argv_index), 0);
22:     sdb_set(db, "qnx.code_offset", sdb_fmt("0x%x", lmfh->code_offset), 0);
23:     sdb_set(db, "qnx.stack_nbytes", sdb_fmt("0x%x", lmfh->stack_nbytes), 0);
24:     sdb_set(db, "qnx.heap_nbytes", sdb_fmt("0x%x", lmfh->heap_nbytes), 0);
25:     sdb_set(db, "qnx.image_base", sdb_fmt("0x%x", lmfh->image_base), 0);

librz/bin/p/bin_pe.inc
71:             key = sdb_fmt("pe.tls_callback%d_paddr", count);
77:             key = sdb_fmt("pe.tls_callback%d_vaddr", count);
83:             key = sdb_fmt("pe.tls_callback%d_haddr", count);
510:    ret->claimed_checksum = strdup(sdb_fmt("0x%08x", claimed_checksum));
511:    ret->actual_checksum = strdup(sdb_fmt("0x%08x", actual_checksum));

librz/bin/p/bin_pe.c
134:    rz_list_append(ret, rz_bin_field_new(addr, addr, siz, nam, sdb_fmt("0x%08x", val), fmt, false));

librz/asm/p/asm_dalvik.c
38:                             buf_asm = sdb_fmt("packed-switch-payload %d, %d", array_size, first_key);
50:                             buf_asm = sdb_fmt("sparse-switch-payload %d", array_size);
63:                             buf_asm = sdb_fmt("fill-array-data-payload %d, %d", elem_width, array_size);

librz/asm/p/asm_ebc.c
16:             ? sdb_fmt("%s %s", cmd.instr, cmd.operands)

librz/bin/p/bin_mdmp.c
61:     ret->claimed_checksum = strdup(sdb_fmt("0x%08x", obj->hdr->check_sum)); // FIXME: Leaks
68:     sdb_set(bf->sdb, "mdmp.flags", sdb_fmt("0x%08" PFMT64x, obj->hdr->flags), 0);
337:            ptr->name = strdup(sdb_fmt("paddr=0x%08" PFMT32x " state=0x%08" PFMT64x
360:            ptr->name = strdup(sdb_fmt("paddr=0x%08" PFMT64x " state=0x%08" PFMT64x

librz/asm/p/asm_cr16.c
14:     rz_strbuf_set(&op->buf_asm, sdb_fmt("%s %s", cmd.instr, cmd.operands));

librz/asm/p/asm_chip8.c
22:                     buf_asm = sdb_fmt("scd 0x%01x", nibble);
35:     case 0x1000: buf_asm = sdb_fmt("jp 0x%03x", nnn); break;
36:     case 0x2000: buf_asm = sdb_fmt("call 0x%03x", nnn); break;
37:     case 0x3000: buf_asm = sdb_fmt("se v%1x, 0x%02x", x, kk); break;
38:     case 0x4000: buf_asm = sdb_fmt("sne v%1x, 0x%02x", x, kk); break;
39:     case 0x5000: buf_asm = sdb_fmt("se v%1x, v%1x", x, y); break;
40:     case 0x6000: buf_asm = sdb_fmt("ld v%1x, 0x%02x", x, kk); break;
41:     case 0x7000: buf_asm = sdb_fmt("add v%1x, 0x%02x", x, kk); break;
44:             case 0x0: buf_asm = sdb_fmt("ld v%1x, v%1x", x, y); break;
45:             case 0x1: buf_asm = sdb_fmt("or v%1x, v%1x", x, y); break;
46:             case 0x2: buf_asm = sdb_fmt("and v%1x, v%1x", x, y); break;
47:             case 0x3: buf_asm = sdb_fmt("xor v%1x, v%1x", x, y); break;
48:             case 0x4: buf_asm = sdb_fmt("add v%1x, v%1x", x, y); break;
49:             case 0x5: buf_asm = sdb_fmt("sub v%1x, v%1x", x, y); break;
50:             case 0x6: buf_asm = sdb_fmt("shr v%1x, v%1x", x, y); break;
51:             case 0x7: buf_asm = sdb_fmt("subn v%1x, v%1x", x, y); break;
52:             case 0xE: buf_asm = sdb_fmt("shl v%1x, v%1x", x, y); break;
55:     case 0x9000: buf_asm = sdb_fmt("sne v%1x, v%1x", x, y); break;
56:     case 0xA000: buf_asm = sdb_fmt("ld i, 0x%03x", nnn); break;
57:     case 0xB000: buf_asm = sdb_fmt("jp v0, 0x%03x", nnn); break;
58:     case 0xC000: buf_asm = sdb_fmt("rnd v%1x, 0x%02x", x, kk); break;
59:     case 0xD000: buf_asm = sdb_fmt("drw v%1x, v%1x, 0x%01x", x, y, nibble); break;
62:                     buf_asm = sdb_fmt("skp v%1x", x);
64:                     buf_asm = sdb_fmt("sknp v%1x", x);
69:             case 0x07: buf_asm = sdb_fmt("ld v%1x, dt", x); break;
70:             case 0x0A: buf_asm = sdb_fmt("ld v%1x, k", x); break;
71:             case 0x15: buf_asm = sdb_fmt("ld dt, v%1x", x); break;
72:             case 0x18: buf_asm = sdb_fmt("ld st, v%1x", x); break;
73:             case 0x1E: buf_asm = sdb_fmt("add i, v%1x", x); break;
74:             case 0x29: buf_asm = sdb_fmt("ld f, v%1x", x); break;
75:             case 0x33: buf_asm = sdb_fmt("ld b, v%1x", x); break;
76:             case 0x55: buf_asm = sdb_fmt("ld [i], v%1x", x); break;
77:             case 0x65: buf_asm = sdb_fmt("ld v%1x, [i]", x); break;
78:             case 0x30: buf_asm = sdb_fmt("ld hf, v%1x", x); break;
79:             case 0x75: buf_asm = sdb_fmt("ld r, v%1x", x); break;
80:             case 0x85: buf_asm = sdb_fmt("ld v%1x, r", x); break;

librz/asm/p/asm_h8300.c
14:     rz_strbuf_set(&op->buf_asm, sdb_fmt("%s %s", cmd.instr, cmd.operands));

librz/asm/p/asm_6502_cs.c
49:                     char *buf_asm = sdb_fmt("%s%s%s",

librz/bin/p/bin_dex.c
81:     return sdb_num_get(mdb, sdb_fmt("method.%d", idx), 0);
1400:                           sdb_num_set(mdb, sdb_fmt("method.%" PFMT64d, MI), sym->paddr, 0);
1410:                                           sdb_num_set (cdb, sdb_fmt ("%d", c->class_id), sym->paddr, 0);
1727:                           const char *mname = sdb_fmt("method.%" PFMT64d, (ut64)i);
2107:   rz_list_append(ret, rz_bin_field_new(addr, addr, siz, nam, sdb_fmt("0x%08" PFMT64x, (ut64)val), fmt, false)); \

librz/bin/p/bin_avr.c
126:            addsym(ret, sdb_fmt("vector.%s", name), addr);
128:            addsym(ret, sdb_fmt("syscall.%s", name), ptr_addr);

librz/bin/format/objc/mach0_classes.c
1090:           sdb_num_set(bin->kv, sdb_fmt("objc_class_%s.offset", klass->name), s, 0);
1093:   sdb_set(bin->kv, sdb_fmt("objc_class.format"), "lllll isa super cache vtable data", 0);
1095:   sdb_set(bin->kv, sdb_fmt("objc_class.format"), "xxxxx isa super cache vtable data", 0);

librz/bin/p/bin_coff.c
122:            ptr->type = rz_str_constpool_get(&rbin->constpool, sdb_fmt("%i", s->n_sclass));

librz/bin/format/pe/pe.c
428:    char *foo = sdb_get(db, sdb_fmt("%d", ordinal), 0);
496:                                    filename = sdb_fmt("%s.sdb", symdllname);
501:                                            filename = sdb_fmt(RZ_JOIN_4_PATHS("%s", RZ_SDB_FORMAT, "dll", "%s.sdb"),
1661:           key = sdb_fmt("pe.tls_callback%d_vaddr", count);
1663:           key = sdb_fmt("pe.tls_callback%d_paddr", count);
1666:           key = sdb_fmt("pe.tls_callback%d_haddr", count);
3106:           key = sdb_fmt("resource.%d.timestr", index);
3108:           key = sdb_fmt("resource.%d.vaddr", index);
3111:           key = sdb_fmt("resource.%d.name", index);
3113:           key = sdb_fmt("resource.%d.size", index);
3115:           key = sdb_fmt("resource.%d.type", index);
3117:           key = sdb_fmt("resource.%d.language", index);

librz/bin/format/mach0/mach0.c
347:    sdb_num_set(bin->kv, sdb_fmt("mach0_segment64_%zu.offset", j), off, 0);
349:    sdb_num_set(bin->kv, sdb_fmt("mach0_segment_%zu.offset", j), off, 0);
409:                    sdb_num_set(bin->kv, sdb_fmt("mach0_section_%.16s_%.16s.offset", bin->sects[k].segname, bin->sects[k].sectname), offset, 0);
411:                    sdb_set(bin->kv, sdb_fmt("mach0_section_%.16s_%.16s.format", bin->sects[k].segname, bin->sects[k].sectname), "mach0_section64", 0);
413:                    sdb_set(bin->kv, sdb_fmt("mach0_section_%.16s_%.16s.format", bin->sects[k].segname, bin->sects[k].sectname), "mach0_section", 0);
1726:           sdb_num_set(bin->kv, sdb_fmt("mach0_cmd_%d.offset", i), off, 0);
1729:                   sdb_set(bin->kv, sdb_fmt("mach0_cmd_%d.format", i), format_name, 0);
1731:                   sdb_set(bin->kv, sdb_fmt("mach0_cmd_%d.format", i), "[4]Ed (mach_load_command_type)cmd size", 0);
1736:                   sdb_set(bin->kv, sdb_fmt("mach0_cmd_%d.cmd", i), "data_in_code", 0);
1739:                   sdb_set(bin->kv, sdb_fmt("mach0_cmd_%d.cmd", i), "rpath", 0);
1744:                   sdb_set(bin->kv, sdb_fmt("mach0_cmd_%d.cmd", i), "segment", 0);
1753:                   sdb_set(bin->kv, sdb_fmt("mach0_cmd_%d.cmd", i), "symtab", 0);
1760:                   sdb_set(bin->kv, sdb_fmt("mach0_cmd_%d.cmd", i), "dysymtab", 0);
1767:                   sdb_set(bin->kv, sdb_fmt("mach0_cmd_%d.cmd", i), "dylib_code_sign_drs", 0);
1771:                   sdb_set(bin->kv, sdb_fmt("mach0_cmd_%d.cmd", i), "version_min_macosx", 0);
1777:                   sdb_set(bin->kv, sdb_fmt("mach0_cmd_%d.cmd", i), "version_min_iphoneos", 0);
1783:                   sdb_set(bin->kv, sdb_fmt("mach0_cmd_%d.cmd", i), "version_min_tvos", 0);
1787:                   sdb_set(bin->kv, sdb_fmt("mach0_cmd_%d.cmd", i), "version_min_watchos", 0);
1791:                   sdb_set(bin->kv, sdb_fmt("mach0_cmd_%d.cmd", i), "uuid", 0);
1811:                   sdb_set(bin->kv, sdb_fmt("mach0_cmd_%d.cmd", i), "encryption_info", 0);
1836:                   sdb_set(bin->kv, sdb_fmt("mach0_cmd_%d.cmd", i), "dylinker", 0);
1869:                   sdb_set(bin->kv, sdb_fmt("mach0_cmd_%d.cmd", i), "main", 0);
1892:                   sdb_set(bin->kv, sdb_fmt("mach0_cmd_%d.cmd", i), "unixthread", 0);
1898:                   sdb_set(bin->kv, sdb_fmt("mach0_cmd_%d.cmd", i), "thread", 0);
1907:                   sdb_set(bin->kv, sdb_fmt("mach0_cmd_%d.cmd", i), "load_dylib", 0);
1918:                   sdb_set(bin->kv, sdb_fmt("mach0_cmd_%d.cmd", i), "dyld_info", 0);
1947:                   sdb_set(bin->kv, sdb_fmt("mach0_cmd_%d.cmd", i), "signature", 0);
1952:                   sdb_set(bin->kv, sdb_fmt("mach0_cmd_%d.cmd", i), "version", 0);
1958:                   sdb_set(bin->kv, sdb_fmt("mach0_cmd_%d.cmd", i), "split_info", 0);
1962:                   sdb_set(bin->kv, sdb_fmt("mach0_cmd_%d.cmd", i), "function_starts", 0);
1968:                   sdb_set(bin->kv, sdb_fmt("mach0_cmd_%d.cmd", i), "dylib", 0);
1993:           sdb_num_set(bin->kv, sdb_fmt("mach0_cmd_%d.offset", i), off, 0);
1996:                   sdb_set(bin->kv, sdb_fmt("mach0_cmd_%d.format", i), format_name, 0);
1998:                   sdb_set(bin->kv, sdb_fmt("mach0_cmd_%d.format", i), "[4]Ed (mach_load_command_type)cmd size", 0);
2003:                   sdb_set(bin->kv, sdb_fmt("mach0_cmd_%d.cmd", i), "data_in_code", 0);
3693:           sdb_set(bin->kv, sdb_fmt("libs.%d.name", i), bin->libs[i], 0);
3708:           sdb_set(bin->kv, sdb_fmt("libs.%d.name", i), bin->libs[i], 0);
4355:                   rz_list_append(ret, rz_bin_field_new(addr, addr, 1, sdb_fmt("load_command_%d_%s", n, cmd_to_string(lcType)), pf_definition, pf_definition, true));
4363:                           rz_list_append(ret, rz_bin_field_new(addr + off, addr + off, 1, sdb_fmt("tool_%d", j++), "mach0_build_version_tool", "mach0_build_version_tool", true));
4376:                                   sdb_fmt("section_%zu", j++), sname, sname, true);

librz/bin/format/mdmp/mdmp.c
476:                    sdb_fmt("d[%d]? "
497:                    sdb_fmt("d[%d]? "
522:                    sdb_fmt("d[%d]? "
608:                    sdb_fmt("d[%d]? NumberOfThreads "
633:                    sdb_fmt("qq[%" PFMT64d "]? NumberOfMemoryRanges "
790:                    sdb_fmt("ddq[%" PFMT64d "]? SizeOfHeader SizeOfEntry "

librz/bin/format/mdmp/mdmp_pe.c
17:             key = sdb_fmt("pe.tls_callback%d_paddr", count);
23:             key = sdb_fmt("pe.tls_callback%d_vaddr", count);
29:             key = sdb_fmt("pe.tls_callback%d_haddr", count);

librz/bin/format/elf/elf.c
1046:                           tmp_val = strdup(sdb_fmt("%x ", data[i + j] & 0x7FFF));
1091:                                                   sdb_set(sdb, key, sdb_fmt("%s(%s)", tmp_val, bin->strtab + vna.vna_name), 0);
1142:                                                   const char *fname = sdb_fmt("%s(%s%-*s)", tmp_val, name, (int)(12 - strlen(name)), ")");

librz/asm/arch/snes/snesdis.c
25:                     buf_asm = sdb_fmt(s_op->name, (ut32)(pc + 2 + (st8)buf[1]));
27:                     buf_asm = sdb_fmt(s_op->name, buf[1]);
32:                     buf_asm = sdb_fmt(s_op->name, buf[1], buf[2]);
34:                     buf_asm = sdb_fmt(s_op->name, pc + 3 + (st16)ut8p_bw(buf + 1));
36:                     buf_asm = sdb_fmt(s_op->name, ut8p_bw(buf + 1));
40:             buf_asm = sdb_fmt(s_op->name, buf[1] | buf[2] << 8 | buf[3] << 16);
44:                     buf_asm = sdb_fmt("%s #0x%02x", s_op->name, buf[1]);
46:                     buf_asm = sdb_fmt("%s #0x%04x", s_op->name, ut8p_bw(buf + 1));
51:                     buf_asm = sdb_fmt("%s #0x%02x", s_op->name, buf[1]);
53:                     buf_asm = sdb_fmt("%s #0x%04x", s_op->name, ut8p_bw(buf + 1));

librz/asm/arch/z80/z80.c
83:             buf_asm = sdb_fmt ("%s", z_op[buf[0]].name);
86:             buf_asm = sdb_fmt (z_op[buf[0]].name, buf[1]);
89:             buf_asm = sdb_fmt (z_op[buf[0]].name, buf[1]+(buf[2]<<8));
93:             buf_asm = sdb_fmt ("%s", cb_tab[buf[1]]);
99:                     buf_asm = sdb_fmt ("%s", z_op[res].name);
102:                    buf_asm = sdb_fmt (z_op[res].name, buf[2]+(buf[3]<<8));
109:                    buf_asm = sdb_fmt ("%s", z_op[res].name);
112:                    buf_asm = sdb_fmt (z_op[res].name, buf[2]+(buf[3]<<8));
115:                    buf_asm = sdb_fmt (z_op[res].name, buf[2]);
119:                    buf_asm = sdb_fmt (cb_tab[z80_op_24_branch_index_res (buf[3])], buf[2]);
122:                    buf_asm = sdb_fmt (z_op[res].name, buf[2], buf[3]);

librz/asm/arch/riscv/riscv.c
312:            rz_asm_op_set_asm (rop, sdb_fmt ("invalid word(%"PFMT64x")", (ut64)word));

librz/asm/arch/pic/pic_midrange.c
194:            buf_asm = sdb_fmt("%s 0x%x", op_info->mnemonic, instr & PIC_MIDRANGE_OP_ARGS_2F_MASK_F);
197:            buf_asm = sdb_fmt("%s 0x%x", op_info->mnemonic, instr & PIC_MIDRANGE_OP_ARGS_7F_MASK_F);
200:            buf_asm = sdb_fmt("%s 0x%x, %c", op_info->mnemonic,
206:                    buf_asm = sdb_fmt("%s FSR%d, 0x%x", op_info->mnemonic,
211:                    buf_asm = sdb_fmt("%s 0x%x[FSR%d]", op_info->mnemonic,
217:            buf_asm = sdb_fmt("%s 0x%x, %d", op_info->mnemonic, instr & PIC_MIDRANGE_OP_ARGS_3B_7F_MASK_F,
221:            buf_asm = sdb_fmt("%s 0x%x", op_info->mnemonic, instr & PIC_MIDRANGE_OP_ARGS_4K_MASK_K);
224:            buf_asm = sdb_fmt("%s 0x%x", op_info->mnemonic, instr & PIC_MIDRANGE_OP_ARGS_8K_MASK_K);
229:            buf_asm = sdb_fmt("%s %s0x%x",
234:            buf_asm = sdb_fmt("%s 0x%x", op_info->mnemonic, instr & PIC_MIDRANGE_OP_ARGS_11K_MASK_K);
242:            buf_asm = sdb_fmt("%s %s", op_info->mnemonic, fsr_op);

librz/asm/arch/pic/pic_pic18.c
142:            buf_asm = sdb_fmt("%s 0x%x", ops[i].name, instr & 0xff);
145:            buf_asm = sdb_fmt("%s 0x%x, %d, %d", ops[i].name, instr & 0xff, (instr >> 9) & 1, (instr >> 8) & 1);
148:            buf_asm = sdb_fmt("%s 0x%x, %d", ops[i].name, instr & 0xff, (instr >> 8) & 1);
151:            buf_asm = sdb_fmt("%s 0x%x, %d, %d", ops[i].name, instr & 0xff, (instr >> 9) & 0x7, (instr >> 8) & 0x1);
154:            buf_asm = sdb_fmt("%s 0x%x", ops[i].name, instr & 0x7ff);
168:                    buf_asm = sdb_fmt("%s 0x%x, %d", ops[i].name,
182:                    buf_asm = sdb_fmt("%s 0x%x", ops[i].name,
196:                    buf_asm = sdb_fmt("%s 0x%x, 0x%x", ops[i].name,
201:            buf_asm = sdb_fmt("%s 0x%x", ops[i].name, instr & 0xf);
204:            buf_asm = sdb_fmt("%s %d", ops[i].name, instr & 0x1);
213:            buf_asm = sdb_fmt("%s %s, %d", ops[i].name, fsr[reg_n],

librz/asm/arch/pic/pic_baseline.c
225:            buf_asm = sdb_fmt("%s 0x%x", op_info->mnemonic, instr & PIC_BASELINE_OP_ARGS_2F_MASK_F);
228:            buf_asm = sdb_fmt("%s 0x%x", op_info->mnemonic, instr & PIC_BASELINE_OP_ARGS_3F_MASK_F);
231:            buf_asm = sdb_fmt("%s 0x%x", op_info->mnemonic, instr & PIC_BASELINE_OP_ARGS_3K_MASK_K);
234:            buf_asm = sdb_fmt("%s 0x%x, %c", op_info->mnemonic, instr & PIC_BASELINE_OP_ARGS_1D_5F_MASK_F,
238:            buf_asm = sdb_fmt("%s 0x%x", op_info->mnemonic, instr & PIC_BASELINE_OP_ARGS_5F_MASK_F);
241:            buf_asm = sdb_fmt("%s 0x%x, 0x%x", op_info->mnemonic, instr & PIC_BASELINE_OP_ARGS_3B_5F_MASK_F,
245:            buf_asm = sdb_fmt("%s 0x%x", op_info->mnemonic, instr & PIC_BASELINE_OP_ARGS_8K_MASK_K);
248:            buf_asm = sdb_fmt("%s 0x%x", op_info->mnemonic, instr & PIC_BASELINE_OP_ARGS_9K_MASK_K);

librz/asm/arch/i4004/i4004dis.c
71:     case 1: buf_asm = sdb_fmt("jcn %d 0x%02x", low, buf[1]); break;
74:                     buf_asm = sdb_fmt("src r%d", (low & 0xe));
76:                     buf_asm = sdb_fmt("fim r%d, 0x%02x", (low & 0xe), buf[1]);
81:                     buf_asm = sdb_fmt("jin r%d", (low & 0xe));
83:                     buf_asm = sdb_fmt("fin r%d", (low & 0xe));
86:     case 4: buf_asm = sdb_fmt("jun 0x%03x", ((ut16)(low << 8) | buf[1])); break;
87:     case 5: buf_asm = sdb_fmt("jms 0x%03x", ((ut16)(low << 8) | buf[1])); break;
88:     case 6: buf_asm = sdb_fmt("inc r%d", low); break;
89:     case 7: buf_asm = sdb_fmt("isz r%d, 0x%02x", low, buf[1]); break;
90:     case 8: buf_asm = sdb_fmt("add r%d", low); break;
91:     case 9: buf_asm = sdb_fmt("sub r%d", low); break;
92:     case 10: buf_asm = sdb_fmt("ld r%d", low); break;
93:     case 11: buf_asm = sdb_fmt("xch r%d", low); break;
94:     case 12: buf_asm = sdb_fmt("bbl %d", low); break;
95:     case 13: buf_asm = sdb_fmt("ldm %d", low); break;

librz/asm/arch/gb/gbdis.c
164:            buf_asm = sdb_fmt("%s", gb_op[buf[0]].name);
167:            buf_asm = sdb_fmt("%s %s", cb_ops[buf[1] >> 3u], cb_regs[buf[1] & 7u]);
170:            buf_asm = sdb_fmt(gb_op[buf[0]].name, buf[1]);
173:            buf_asm = sdb_fmt(gb_op[buf[0]].name, buf[1] + 0x100 * buf[2]);
177:            buf_asm = sdb_fmt(gb_op[buf[0]].name, reg);

librz/asm/arch/6502/6502dis.c
150:                            buf_asm = sdb_fmt("%s", ops[i].name);
154:                                    buf_asm = sdb_fmt(ops[i].name, buf[1]);
162:                                    buf_asm = sdb_fmt(ops[i].name, buf[1] + 0x100 * buf[2]);
170:                                    buf_asm = sdb_fmt(ops[i].name, buf[1] + 0x100 * buf[2] + 0x10000 * buf[3]);
ret2libc commented 3 years ago

Currently Rizin uses sdb_fmt function, often as an argument that could cause a leak

I think this is not true. sdb_fmt gets string from the stack, so they cannot leak. However, sdb_fmt has its own problems indeed, because you don't have control over the used buffers. The direct replacement for sdb_fmt should be rz_strf which still uses stack-allocated buffers.

rz_str_* and rz_strbuf_* usually allocates things on the stack and sometimes you don't need to waste time on that.