parse_mips_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 *	mips_tokenize (const char *assembly, size_t length)
static bool	parse (RzParse *parse, const char *assembly, RzStrBuf *sb)
static bool	subvar (RzParse *p, RzAnalysisFunction *f, RzAnalysisOp *op, char *data, char *str, int len)

Variables
static const RzPseudoGrammar	mips_lexicon []
static const RzPseudoDirect	mips_direct []
static const RzPseudoReplace	mips_replace []
static const RzPseudoConfig	mips_config = RZ_PSEUDO_DEFINE_CONFIG(mips_direct, mips_lexicon, mips_replace, 4, mips_tokenize)
RzParsePlugin	rz_parse_plugin_mips_pseudo
RZ_API RzLibStruct	rizin_plugin

Function Documentation

mips_tokenize()

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

static

Definition at line 95 of file parse_mips_pseudo.c.

                                                           {
    size_t i, p;
    char *buf = NULL;
    bool insert_zero = 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] == ',') {
            p++;
        } else if (buf[p] == '(') {
            buf[p] = ' ';
            if (!IS_HEXCHAR(buf[p - 1])) {
                p++;
                insert_zero = true;
            }
        } else if (buf[p] == ')') {
            buf[p] = 0;
        } else if (buf[p] == 'z' && buf[p + 1] == 'e' && buf[p + 2] == 'r' && buf[p + 3] == 'o') {
            p += 3;
            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 (insert_zero) {
        rz_list_insert(tokens, rz_list_length(tokens) - 1, strdup("0"));
    }
 
    return tokens;
}

References free(), i, IS_HEXCHAR, length, NULL, p, rz_list_insert(), rz_list_length(), rz_str_ndup(), rz_str_split_duplist(), and strdup().

parse()

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

static

Definition at line 140 of file parse_mips_pseudo.c.

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

References mips_config, rz_pseudo_convert(), and sb.

subvar()

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

static

Definition at line 144 of file parse_mips_pseudo.c.

                                                                                                        {
    const ut64 addr = op->addr;
    RzListIter *iter;
    char *oldstr;
    char *tstr = strdup(data);
    RzAnalysis *analysis = p->analb.analysis;
 
    if (!p->varlist) {
        free(tstr);
        return false;
    }
    RzList *bpargs = p->varlist(f, 'b');
    RzList *spargs = p->varlist(f, 's');
    const bool ucase = IS_UPPER(*tstr);
    RzAnalysisVarField *var;
    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];
        }
        char *tmpf;
        // TODO: honor asm pseudo
        if (RZ_ABS(delta) < 10) {
            tmpf = "%d(%s)";
        } else if (delta > 0) {
            tmpf = "0x%x(%s)";
        } else {
            tmpf = "-0x%x(%s)";
        }
        oldstr = rz_str_newf(tmpf, RZ_ABS(delta), reg);
        if (ucase) {
            char *comma = strchr(oldstr, ',');
            if (comma) {
                *comma = 0;
                rz_str_case(oldstr, true);
                *comma = ',';
            }
        }
        if (strstr(tstr, oldstr)) {
            char *newstr = (p->localvar_only)
                ? rz_str_newf("(%s)", var->name)
                : rz_str_newf("%s%s(%s)", delta > 0 ? "" : "-", var->name, reg);
            tstr = rz_str_replace(tstr, oldstr, newstr, 1);
            free(newstr);
            free(oldstr);
            break;
        }
        free(oldstr);
    }
    rz_list_foreach (bpargs, iter, var) {
        char *tmpf = NULL;
        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];
        }
        if (RZ_ABS(delta) < 10) {
            tmpf = "%d(%s)";
        } else if (delta > 0) {
            tmpf = "0x%x(%s)";
        } else {
            tmpf = "-0x%x(%s)";
        }
        oldstr = rz_str_newf(tmpf, RZ_ABS(delta), reg);
        if (ucase) {
            char *comma = strchr(oldstr, ',');
            if (comma) {
                *comma = 0;
                rz_str_case(oldstr, true);
                *comma = ',';
            }
        }
        if (strstr(tstr, oldstr)) {
            char *newstr = (p->localvar_only)
                ? rz_str_newf("(%s)", var->name)
                : rz_str_newf("%s%s(%s)", delta > 0 ? "" : "-", var->name, reg);
            tstr = rz_str_replace(tstr, oldstr, newstr, 1);
            free(newstr);
            free(oldstr);
            break;
        }
        free(oldstr);
    }
    bool ret = true;
    if (len > strlen(tstr)) {
        strcpy(str, tstr);
    } else {
        // TOO BIG STRING CANNOT REPLACE HERE
        ret = false;
    }
    free(tstr);
    rz_list_free(bpargs);
    rz_list_free(spargs);
    return ret;
}

References addr, comma, delta, f, free(), IS_UPPER, len, rz_reg_t::name, newstr(), NULL, p, reg, rz_analysis_t::reg, RZ_ABS, rz_list_free(), RZ_REG_NAME_BP, RZ_REG_NAME_SP, rz_str_case(), rz_str_newf(), rz_str_replace(), st64, ST64_MAX, cmd_descs_generate::str, strdup(), and ut64().

Variable Documentation

mips_config

const RzPseudoConfig mips_config = RZ_PSEUDO_DEFINE_CONFIG(mips_direct, mips_lexicon, mips_replace, 4, mips_tokenize)

static

Definition at line 93 of file parse_mips_pseudo.c.

Referenced by parse().

mips_direct

const RzPseudoDirect mips_direct[]

static

Initial value:

= {
    RZ_PSEUDO_DEFINE_DIRECT("jr ra", "return"),
}

Definition at line 83 of file parse_mips_pseudo.c.

mips_lexicon

const RzPseudoGrammar mips_lexicon[]

static

Definition at line 19 of file parse_mips_pseudo.c.

mips_replace

const RzPseudoReplace mips_replace[]

static

Initial value:

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

Definition at line 87 of file parse_mips_pseudo.c.

rizin_plugin

RZ_API RzLibStruct rizin_plugin

Initial value:

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

Definition at line 271 of file parse_mips_pseudo.c.

rz_parse_plugin_mips_pseudo

RzParsePlugin rz_parse_plugin_mips_pseudo

Initial value:

= {
    .name = "mips.pseudo",
    .desc = "MIPS pseudo syntax",
    .init = NULL,
    .fini = NULL,
    .parse = parse,
    .subvar = subvar,
}

Definition at line 261 of file parse_mips_pseudo.c.