parse_arm_pseudo.c File Reference

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <rz_lib.h>
#include <rz_util.h>
#include <rz_flag.h>
#include <rz_analysis.h>
#include <rz_parse.h>
#include "parse_common.c"

Go to the source code of this file.

Functions
static RzList *	arm_tokenize (const char *assembly, size_t length)
static bool	parse (RzParse *p, const char *assembly, RzStrBuf *sb)
static char *	subs_var_string (RzParse *p, RzAnalysisVarField *var, char *tstr, const char *oldstr, const char *reg, int delta)
static char *	mount_oldstr (RzParse *p, const char *reg, st64 delta, bool ucase)
static bool	subvar (RzParse *p, RzAnalysisFunction *f, RzAnalysisOp *op, char *data, char *str, int len)

Variables
static const RzPseudoGrammar	arm_lexicon []
static const RzPseudoDirect	arm_direct []
static const RzPseudoReplace	arm_replace []
static const RzPseudoConfig	arm_config = RZ_PSEUDO_DEFINE_CONFIG(arm_direct, arm_lexicon, arm_replace, 5, arm_tokenize)
RzParsePlugin	rz_parse_plugin_arm_pseudo
RZ_API RzLibStruct	rizin_plugin

Function Documentation

arm_tokenize()

RzList * arm_tokenize ( const char *  assembly, size_t  length  )

static

Definition at line 136 of file parse_arm_pseudo.c.

                                                          {
    size_t i, p;
    char *buf = NULL;
    const char *comma_replace = NULL;
    bool keep = false;
    RzList *tokens = NULL;
 
    buf = rz_str_ndup(assembly, length);
    if (!buf) {
        return NULL;
    }
 
    for (i = 0, p = 0; p < length; ++i, ++p) {
        if (buf[p] == ',') {
            if (!keep) {
                p++;
            } else if (buf[p + 1] == ' ') {
                buf[i] = buf[p];
                p++;
                continue;
            }
        } else if (buf[p] == '(') {
            buf[p] = ' ';
        } else if (buf[p] == ')') {
            buf[p] = ' ';
        } else if (buf[p] == '[') {
            keep = true;
            comma_replace = " + ";
        } else if (buf[p] == ']') {
            keep = false;
        } else if (buf[p] == '{') {
            if (strchr(buf + p + 1, ',') < strchr(buf + p + 1, '}')) {
                keep = true;
                comma_replace = ", ";
            } else {
                p++;
            }
        } else if (buf[p] == '}') {
            if (!comma_replace) {
                p++;
            }
            keep = false;
        } else if ((buf[p] == 'w' || buf[p] == 'x') && buf[p + 1] == 'z' && buf[p + 2] == 'r') {
            p += 2;
            buf[p] = '0';
        }
        if (p > i) {
            buf[i] = buf[p];
        }
    }
    buf[i] = 0;
 
    tokens = rz_str_split_duplist(buf, " ", true);
    free(buf);
    if (!tokens) {
        return NULL;
    }
 
    if (comma_replace) {
        RzListIter *it;
        rz_list_foreach (tokens, it, buf) {
            it->data = rz_str_replace(buf, ",", comma_replace, 1);
        }
    }
 
    return tokens;
}

References rz_list_iter_t::data, free(), i, length, NULL, p, rz_str_ndup(), rz_str_replace(), and rz_str_split_duplist().

mount_oldstr()

static char* mount_oldstr ( RzParse *  p, const char *  reg, st64  delta, bool  ucase  )

static

Definition at line 225 of file parse_arm_pseudo.c.

                                                                               {
    const char *tmplt;
    char *oldstr;
    if (delta > -10 && delta < 10) {
        if (p->pseudo) {
            char sign = '+';
            if (delta < 0) {
                sign = '-';
            }
            oldstr = rz_str_newf("%s %c %" PFMT64d, reg, sign, RZ_ABS(delta));
        } else {
            oldstr = rz_str_newf("%s, %" PFMT64d, reg, delta);
        }
    } else if (delta > 0) {
        tmplt = p->pseudo ? "%s + 0x%x" : (ucase ? "%s, 0x%X" : "%s, 0x%x");
        oldstr = rz_str_newf(tmplt, reg, delta);
    } else {
        tmplt = p->pseudo ? "%s - 0x%x" : (ucase ? "%s, -0x%X" : "%s, -0x%x");
        oldstr = rz_str_newf(tmplt, reg, -delta);
    }
    if (ucase) {
        char *comma = strchr(oldstr, ',');
        if (comma) {
            *comma = 0;
            rz_str_case(oldstr, true);
            *comma = ',';
        }
    }
    return oldstr;
}

References comma, delta, p, PFMT64d, reg, RZ_ABS, rz_str_case(), and rz_str_newf().

Referenced by subvar().

parse()

static bool parse ( RzParse *  p, const char *  assembly, RzStrBuf *  sb  )

static

Definition at line 204 of file parse_arm_pseudo.c.

                                                                  {
    return rz_pseudo_convert(&arm_config, assembly, sb);
}

References arm_config, rz_pseudo_convert(), and sb.

subs_var_string()

static char* subs_var_string ( RzParse *  p, RzAnalysisVarField *  var, char *  tstr, const char *  oldstr, const char *  reg, int  delta  )

static

Definition at line 208 of file parse_arm_pseudo.c.

                                                                                                                              {
    char *newstr = p->localvar_only
        ? rz_str_newf("%s", var->name)
        : rz_str_newf("%s %c %s", reg, delta > 0 ? '+' : '-', var->name);
    if (IS_UPPER(*tstr)) {
        char *space = strrchr(newstr, ' ');
        if (space) {
            *space = 0;
            rz_str_case(newstr, true);
            *space = ' ';
        }
    }
    char *ret = rz_str_replace(tstr, oldstr, newstr, 1);
    free(newstr);
    return ret;
}

References delta, free(), IS_UPPER, newstr(), p, reg, rz_str_case(), rz_str_newf(), and rz_str_replace().

Referenced by subvar().

subvar()

static bool subvar ( RzParse *  p, RzAnalysisFunction *  f, RzAnalysisOp *  op, char *  data, char *  str, int  len  )

static

Definition at line 256 of file parse_arm_pseudo.c.

                                                                                                        {
    const ut64 addr = op->addr;
    const int oplen = op->size;
    RzList *spargs = NULL;
    RzList *bpargs = NULL;
    RzListIter *iter;
    RzAnalysis *analysis = p->analb.analysis;
    char *oldstr;
    char *tstr = strdup(data);
    if (!tstr) {
        return false;
    }
 
    if (!p->varlist) {
        free(tstr);
        return false;
    }
    if (p->subrel) {
        char *rip;
        if (p->pseudo) {
            rip = (char *)rz_str_casestr(tstr, "[pc +");
            if (!rip) {
                rip = (char *)rz_str_casestr(tstr, "[pc -");
            }
        } else {
            rip = (char *)rz_str_casestr(tstr, "[pc, ");
        }
 
        if (rip) {
            rip += 4;
            char *tstr_new, *ripend = strchr(rip, ']');
            const char *neg = strchr(rip, '-');
            ut64 off = (oplen == 2 || strstr(tstr, ".w") || strstr(tstr, ".W")) ? 4 : 8;
            ut64 repl_num = (addr + off) & ~3;
            if (!ripend) {
                ripend = "]";
            }
            const char *maybe_num = neg ? neg + 1 : rip;
            maybe_num = rz_str_trim_head_ro(maybe_num);
            if (rz_is_valid_input_num_value(NULL, maybe_num)) {
                if (neg) {
                    repl_num -= rz_num_get(NULL, maybe_num);
                } else {
                    repl_num += rz_num_get(NULL, maybe_num);
                }
                rip -= 3;
                *rip = 0;
                tstr_new = rz_str_newf("%s0x%08" PFMT64x "%s", tstr, repl_num, ripend);
                free(tstr);
                tstr = tstr_new;
            }
        }
    }
 
    bpargs = p->varlist(f, 'b');
    spargs = p->varlist(f, 's');
    bool ucase = IS_UPPER(*tstr);
    RzAnalysisVarField *var;
    rz_list_foreach (bpargs, iter, var) {
        st64 delta = p->get_ptr_at
            ? p->get_ptr_at(f, var->delta, addr)
            : ST64_MAX;
        if (delta == ST64_MAX && var->field) {
            delta = var->delta + f->bp_off;
        } else if (delta == ST64_MAX) {
            continue;
        }
        const char *reg = NULL;
        if (p->get_reg_at) {
            reg = p->get_reg_at(f, var->delta, addr);
        }
        if (!reg) {
            reg = analysis->reg->name[RZ_REG_NAME_BP];
        }
        oldstr = mount_oldstr(p, reg, delta, ucase);
        if (strstr(tstr, oldstr)) {
            tstr = subs_var_string(p, var, tstr, oldstr, reg, delta);
            free(oldstr);
            break;
        }
        free(oldstr);
    }
    rz_list_foreach (spargs, iter, var) {
        st64 delta = p->get_ptr_at
            ? p->get_ptr_at(f, var->delta, addr)
            : ST64_MAX;
        if (delta == ST64_MAX && var->field) {
            delta = var->delta;
        } else if (delta == ST64_MAX) {
            continue;
        }
        const char *reg = NULL;
        if (p->get_reg_at) {
            reg = p->get_reg_at(f, var->delta, addr);
        }
        if (!reg) {
            reg = analysis->reg->name[RZ_REG_NAME_SP];
        }
        oldstr = mount_oldstr(p, reg, delta, ucase);
        if (strstr(tstr, oldstr)) {
            tstr = subs_var_string(p, var, tstr, oldstr, reg, delta);
            free(oldstr);
            break;
        }
        free(oldstr);
    }
    rz_list_free(bpargs);
    rz_list_free(spargs);
    if (len > strlen(tstr)) {
        strcpy(str, tstr);
    } else {
        // TOO BIG STRING CANNOT REPLACE HERE
        free(tstr);
        return false;
    }
    free(tstr);
    return true;
}

References addr, delta, f, free(), IS_UPPER, len, mount_oldstr(), rz_reg_t::name, neg(), NULL, off, p, PFMT64x, reg, rz_analysis_t::reg, rip(), rz_is_valid_input_num_value(), rz_list_free(), rz_num_get(), RZ_REG_NAME_BP, RZ_REG_NAME_SP, rz_str_casestr(), rz_str_newf(), rz_str_trim_head_ro(), st64, ST64_MAX, cmd_descs_generate::str, strdup(), subs_var_string(), and ut64().

Referenced by sh_il_negc().

Variable Documentation

arm_config

const RzPseudoConfig arm_config = RZ_PSEUDO_DEFINE_CONFIG(arm_direct, arm_lexicon, arm_replace, 5, arm_tokenize)

static

Definition at line 134 of file parse_arm_pseudo.c.

Referenced by parse().

arm_direct

const RzPseudoDirect arm_direct[]

static

Initial value:

= {
    RZ_PSEUDO_DEFINE_DIRECT("beq lr", "if (? == ?) return"),
    RZ_PSEUDO_DEFINE_DIRECT("bx lr", "return"),
}

Definition at line 121 of file parse_arm_pseudo.c.

arm_lexicon

const RzPseudoGrammar arm_lexicon[]

static

Definition at line 18 of file parse_arm_pseudo.c.

arm_replace

const RzPseudoReplace arm_replace[]

static

Initial value:

= {
    RZ_PSEUDO_DEFINE_REPLACE(" + 0]", "]", 0),
    RZ_PSEUDO_DEFINE_REPLACE("+ -", "- ", 1),
    RZ_PSEUDO_DEFINE_REPLACE("0 << 16", "0", 1),
    RZ_PSEUDO_DEFINE_REPLACE("{", "(", 1),
    RZ_PSEUDO_DEFINE_REPLACE("}", ")", 1),
}

Definition at line 126 of file parse_arm_pseudo.c.

rizin_plugin

RZ_API RzLibStruct rizin_plugin

Initial value:

= {
    .type = RZ_LIB_TYPE_PARSE,
    .data = &rz_parse_plugin_arm_pseudo,
    .version = RZ_VERSION
}

Definition at line 383 of file parse_arm_pseudo.c.

rz_parse_plugin_arm_pseudo

RzParsePlugin rz_parse_plugin_arm_pseudo

Initial value:

= {
    .name = "arm.pseudo",
    .desc = "ARM/ARM64 pseudo syntax",
    .parse = parse,
    .subvar = &subvar,
}

Definition at line 375 of file parse_arm_pseudo.c.