OP_SHL,
OP_SHR,
OP_SAR,
+ OP_SHRD,
OP_ROL,
OP_ROR,
OP_RCL,
OP_JECXZ,
OP_JCC,
OP_SCC,
+ // x87
+ // mmx
+ OP_EMMS,
};
enum opr_type {
OPLM_BYTE,
OPLM_WORD,
OPLM_DWORD,
+ OPLM_QWORD,
};
#define MAX_OPERANDS 3
printf("%s:%d: note: [%s] '%s': " fmt, asmfn, (op_)->asmln, g_func, \
dump_op(op_), ##__VA_ARGS__)
-#define MAX_REGS 8
-
-const char *regs_r32[] = { "eax", "ebx", "ecx", "edx", "esi", "edi", "ebp", "esp" };
+const char *regs_r32[] = {
+ "eax", "ebx", "ecx", "edx", "esi", "edi", "ebp", "esp",
+ // not r32, but list here for easy parsing and printing
+ "mm0", "mm1", "mm2", "mm3", "mm4", "mm5", "mm6", "mm7",
+};
const char *regs_r16[] = { "ax", "bx", "cx", "dx", "si", "di", "bp", "sp" };
const char *regs_r8l[] = { "al", "bl", "cl", "dl" };
const char *regs_r8h[] = { "ah", "bh", "ch", "dh" };
PFO_LE, // e ZF=1||SF!=OF
};
+#define PFOB_O (1 << PFO_O)
+#define PFOB_C (1 << PFO_C)
+#define PFOB_Z (1 << PFO_Z)
+#define PFOB_S (1 << PFO_S)
+
static const char *parsed_flag_op_names[] = {
"o", "c", "z", "be", "s", "p", "l", "le"
};
snprintf(buf, buf_size, number < 10 ? "%lu" : "0x%02lx", number);
}
+static int check_segment_prefix(const char *s)
+{
+ if (s[0] == 0 || s[1] != 's' || s[2] != ':')
+ return 0;
+
+ switch (s[0]) {
+ case 'c': return 1;
+ case 'd': return 2;
+ case 's': return 3;
+ case 'e': return 4;
+ case 'f': return 5;
+ case 'g': return 6;
+ default: return 0;
+ }
+}
+
static int parse_reg(enum opr_lenmod *reg_lmod, const char *s)
{
int reg;
reg = char_array_i(regs_r32, ARRAY_SIZE(regs_r32), s);
+ if (reg >= 8) {
+ *reg_lmod = OPLM_QWORD;
+ return reg;
+ }
if (reg >= 0) {
*reg_lmod = OPLM_DWORD;
return reg;
s++;
*d = 0;
- // skip 'ds:' prefix
- if (IS_START(s, "ds:"))
+ // skip '?s:' prefixes
+ if (check_segment_prefix(s))
s += 3;
s = next_idt(w, sizeof(w), s);
opr->lmod = OPLM_BYTE;
return 1;
}
+ if (!strncmp(opr->name, "qword_", 6)) {
+ opr->lmod = OPLM_QWORD;
+ return 1;
+ }
return 0;
}
"int", "_DWORD", "UINT_PTR", "DWORD",
"WPARAM", "LPARAM", "UINT", "__int32",
"LONG", "HIMC", "BOOL", "size_t",
+ "float",
};
static const char *word_types[] = {
"uint16_t", "int16_t", "_WORD", "WORD",
if (label != NULL) {
opr->type = OPT_LABEL;
- if (IS_START(label, "ds:")) {
+ ret = check_segment_prefix(label);
+ if (ret != 0) {
+ if (ret >= 5)
+ aerr("fs/gs used\n");
opr->had_ds = 1;
label += 3;
}
opr->lmod = OPLM_WORD;
else if (IS(words[w], "byte"))
opr->lmod = OPLM_BYTE;
+ else if (IS(words[w], "qword"))
+ opr->lmod = OPLM_QWORD;
else
aerr("type parsing failed\n");
w += 2;
if (wordc_in != 1)
aerr("parse_operand 1 word expected\n");
- if (IS_START(words[w], "ds:")) {
+ ret = check_segment_prefix(words[w]);
+ if (ret != 0) {
+ if (ret >= 5)
+ aerr("fs/gs used\n");
opr->had_ds = 1;
memmove(words[w], words[w] + 3, strlen(words[w]) - 2);
}
{ "shr", OP_SHR, 2, 2, OPF_DATA|OPF_FLAGS },
{ "sal", OP_SHL, 2, 2, OPF_DATA|OPF_FLAGS },
{ "sar", OP_SAR, 2, 2, OPF_DATA|OPF_FLAGS },
+ { "shrd", OP_SHRD, 3, 3, OPF_DATA|OPF_FLAGS },
{ "rol", OP_ROL, 2, 2, OPF_DATA|OPF_FLAGS },
{ "ror", OP_ROR, 2, 2, OPF_DATA|OPF_FLAGS },
{ "rcl", OP_RCL, 2, 2, OPF_DATA|OPF_FLAGS|OPF_CC, PFO_C },
{ "setng", OP_SCC, 1, 1, OPF_DATA|OPF_CC, PFO_LE, 0 },
{ "setg", OP_SCC, 1, 1, OPF_DATA|OPF_CC, PFO_LE, 1 },
{ "setnle", OP_SCC, 1, 1, OPF_DATA|OPF_CC, PFO_LE, 1 },
+ // x87
+ // mmx
+ { "emms", OP_EMMS, 0, 0, OPF_DATA },
+ { "movq", OP_MOV, 2, 2, OPF_DATA },
};
static void parse_op(struct parsed_op *op, char words[16][256], int wordc)
op->operand[1].lmod = OPLM_BYTE;
break;
+ case OP_SHRD:
+ if (op->operand[2].lmod == OPLM_UNSPEC)
+ op->operand[2].lmod = OPLM_BYTE;
+ break;
+
case OP_PUSH:
if (op->operand[0].lmod == OPLM_UNSPEC
&& (op->operand[0].type == OPT_CONST
enum opr_lenmod lmod)
{
switch (lmod) {
+ case OPLM_QWORD:
+ return "u64";
case OPLM_DWORD:
return "u32";
case OPLM_WORD:
enum opr_lenmod lmod)
{
switch (lmod) {
+ case OPLM_QWORD:
+ return "";
case OPLM_DWORD:
return "";
case OPLM_WORD:
enum opr_lenmod lmod)
{
switch (lmod) {
+ case OPLM_QWORD:
+ return "*(u64 *)";
case OPLM_DWORD:
return "*(u32 *)";
case OPLM_WORD:
enum opr_lenmod lmod)
{
switch (lmod) {
+ case OPLM_QWORD:
+ return "(s64)";
case OPLM_DWORD:
return "(s32)";
case OPLM_WORD:
static int lmod_bytes(struct parsed_op *po, enum opr_lenmod lmod)
{
switch (lmod) {
+ case OPLM_QWORD:
+ return 8;
case OPLM_DWORD:
return 4;
case OPLM_WORD:
static const char *opr_reg_p(struct parsed_op *po, struct parsed_opr *popr)
{
- if ((unsigned int)popr->reg >= MAX_REGS)
+ if ((unsigned int)popr->reg >= ARRAY_SIZE(regs_r32))
ferr(po, "invalid reg: %d\n", popr->reg);
return regs_r32[popr->reg];
}
ferr(po, "lea from reg?\n");
switch (popr->lmod) {
+ case OPLM_QWORD:
+ snprintf(buf, buf_size, "%s%s.q", cast, opr_reg_p(po, popr));
+ break;
case OPLM_DWORD:
snprintf(buf, buf_size, "%s%s", cast, opr_reg_p(po, popr));
break;
switch (popr->type) {
case OPT_REG:
switch (popr->lmod) {
+ case OPLM_QWORD:
+ snprintf(buf, buf_size, "%s.q", opr_reg_p(po, popr));
+ break;
case OPLM_DWORD:
snprintf(buf, buf_size, "%s", opr_reg_p(po, popr));
break;
char buf1[256], buf2[256];
enum opr_lenmod lmod;
- if (po->operand[0].lmod != po->operand[1].lmod)
+ if (po->op != OP_DEC && po->operand[0].lmod != po->operand[1].lmod)
ferr(po, "%s: lmod mismatch: %d %d\n", __func__,
po->operand[0].lmod, po->operand[1].lmod);
lmod = po->operand[0].lmod;
}
out_src_opr(buf1, sizeof(buf1), po, &po->operand[0], cast_use, 0);
- out_src_opr(buf2, sizeof(buf2), po, &po->operand[1], cast_use, 0);
+ if (po->op == OP_DEC)
+ snprintf(buf2, sizeof(buf2), "1");
+ else
+ out_src_opr(buf2, sizeof(buf2), po, &po->operand[1], cast_use, 0);
switch (pfo) {
case PFO_C:
buf1, is_inv ? ">=" : "<", buf2);
break;
- case PFO_LE:
+ case PFO_LE: // !g
snprintf(buf, buf_size, "(%s %s %s)",
buf1, is_inv ? ">" : "<=", buf2);
break;
ferr(po, "arg collect %d/%d hit '%s' with %d stack args\n",
arg, pp->argc, opr_name(&ops[j], 0), pp_tmp->argc_stack);
}
- else if (ops[j].op == OP_ADD && ops[j].operand[0].reg == xSP) {
+ // esp adjust of 0 means we collected it before
+ else if (ops[j].op == OP_ADD && ops[j].operand[0].reg == xSP
+ && (ops[j].operand[1].type != OPT_CONST
+ || ops[j].operand[1].val != 0))
+ {
if (pp->is_unresolved)
break;
- ferr(po, "arg collect %d/%d hit esp adjust\n",
- arg, pp->argc);
+ ferr(po, "arg collect %d/%d hit esp adjust of %d\n",
+ arg, pp->argc, ops[j].operand[1].val);
}
else if (ops[j].op == OP_POP) {
if (pp->is_unresolved)
ops[j].p_argnum = arg + 1;
save_args |= 1 << arg;
}
- else if (ops[j].p_argnum < arg + 1)
- ferr(&ops[j], "p_argnum conflict (%d<%d) for '%s'\n",
- ops[j].p_argnum, arg + 1, pp->name);
+ else if (ops[j].p_argnum < arg + 1) {
+ // XXX: might kill valid var..
+ //*save_arg_vars &= ~(1 << (ops[j].p_argnum - 1));
+ ops[j].p_argnum = arg + 1;
+ save_args |= 1 << arg;
+ }
}
else if (ops[j].p_argnum == 0)
ops[j].flags |= OPF_RMD;
regmask_now = regmask & ~regmask_arg;
regmask_now &= ~(1 << xSP);
- if (regmask_now) {
+ if (regmask_now & 0x00ff) {
for (reg = 0; reg < 8; reg++) {
if (regmask_now & (1 << reg)) {
fprintf(fout, " u32 %s", regs_r32[reg]);
}
}
}
+ if (regmask_now & 0xff00) {
+ for (reg = 8; reg < 16; reg++) {
+ if (regmask_now & (1 << reg)) {
+ fprintf(fout, " mmxr %s", regs_r32[reg]);
+ if (regmask_init & (1 << reg))
+ fprintf(fout, " = { 0, }");
+ fprintf(fout, ";\n");
+ had_decl = 1;
+ }
+ }
+ }
if (regmask_save) {
for (reg = 0; reg < 8; reg++) {
delayed_flag_op = NULL;
break;
+ case OP_SHRD:
+ assert_operand_cnt(3);
+ propagate_lmod(po, &po->operand[0], &po->operand[1]);
+ l = lmod_bytes(po, po->operand[0].lmod) * 8;
+ out_dst_opr(buf1, sizeof(buf1), po, &po->operand[0]);
+ out_src_opr_u32(buf2, sizeof(buf2), po, &po->operand[1]);
+ out_src_opr_u32(buf3, sizeof(buf3), po, &po->operand[2]);
+ fprintf(fout, " %s >>= %s; %s |= %s << (%d - %s);",
+ buf1, buf3, buf1, buf2, l, buf3);
+ strcpy(g_comment, "shrd");
+ output_std_flags(fout, po, &pfomask, buf1);
+ last_arith_dst = &po->operand[0];
+ delayed_flag_op = NULL;
+ break;
+
case OP_ROL:
case OP_ROR:
assert_operand_cnt(2);
case OP_SUB:
assert_operand_cnt(2);
propagate_lmod(po, &po->operand[0], &po->operand[1]);
- if (pfomask & (1 << PFO_C)) {
- fprintf(fout, " cond_c = %s < %s;\n",
- out_src_opr_u32(buf1, sizeof(buf1), po, &po->operand[0]),
- out_src_opr_u32(buf2, sizeof(buf2), po, &po->operand[1]));
- pfomask &= ~(1 << PFO_C);
+ if (pfomask & ~((1 << PFO_Z) | (1 << PFO_S))) {
+ for (j = 0; j <= PFO_LE; j++) {
+ if (!(pfomask & (1 << j)))
+ continue;
+ if (j == PFO_Z || j == PFO_S)
+ continue;
+
+ out_cmp_for_cc(buf1, sizeof(buf1), po, j, 0);
+ fprintf(fout, " cond_%s = %s;\n",
+ parsed_flag_op_names[j], buf1);
+ pfomask &= ~(1 << j);
+ }
}
goto dualop_arith;
strcat(g_comment, "bsf");
break;
- case OP_INC:
case OP_DEC:
+ if (pfomask & ~(PFOB_S | PFOB_S | PFOB_C)) {
+ for (j = 0; j <= PFO_LE; j++) {
+ if (!(pfomask & (1 << j)))
+ continue;
+ if (j == PFO_Z || j == PFO_S || j == PFO_C)
+ continue;
+
+ out_cmp_for_cc(buf1, sizeof(buf1), po, j, 0);
+ fprintf(fout, " cond_%s = %s;\n",
+ parsed_flag_op_names[j], buf1);
+ pfomask &= ~(1 << j);
+ }
+ }
+ // fallthrough
+
+ case OP_INC:
+ if (pfomask & (1 << PFO_C))
+ // carry is unaffected by inc/dec.. wtf?
+ ferr(po, "carry propagation needed\n");
+
out_dst_opr(buf1, sizeof(buf1), po, &po->operand[0]);
if (po->operand[0].type == OPT_REG) {
strcpy(buf2, po->op == OP_INC ? "++" : "--");
no_output = 1;
break;
+ // mmx
+ case OP_EMMS:
+ strcpy(g_comment, "(emms)");
+ break;
+
default:
no_output = 1;
ferr(po, "unhandled op type %d, flags %x\n",
g_eqs[g_eqcnt].lmod = OPLM_WORD;
else if (IS(words[2], "byte"))
g_eqs[g_eqcnt].lmod = OPLM_BYTE;
+ else if (IS(words[2], "qword"))
+ g_eqs[g_eqcnt].lmod = OPLM_QWORD;
else
aerr("bad lmod: '%s'\n", words[2]);
notaz.gp2x.de / ia32rtools.git / blobdiff