+#include <ctype.h>
+#include <errno.h>
+#include <limits.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+union reg {
+ unsigned char *p;
+ long i;
+ long u;
+};
+
+struct regs {
+ union reg
+ a, b, c, d, si, di, bp, f,
+ r8, r9, r10, r11, r12, r13, r14, r15;
+};
+
+struct seg {
+ unsigned char *p;
+ size_t sz;
+};
+
+#define N(v) (sizeof(v)/sizeof((v)[0]))
+
+#define CTYPE_HACK(func, ch) func((unsigned char)(ch))
+#define ISDIGIT(ch) CTYPE_HACK(isdigit, ch)
+#define ISSPACE(ch) CTYPE_HACK(isspace, ch)
+
+#define XCHG(_) \
+ _(x00) _(x01) _(x02) _(x03) _(x04) _(x05) _(x06) _(x07) \
+ _(x08) _(x09) _(x0a) _(x0b) _(x0c) _(x0d) _(x0e) _(x0f) \
+ _(x10) _(x11) _(x12) _(x13) _(x14) _(x15) _(x16) _(x17) \
+ _(x18) _(x19) _(x1a) _(x1b) _(x1c) _(x1d) _(x1e) _(x1f) \
+ _(x20) _(x21) _(x22) _(x23) _(x24) _(x25) _(x26) _(x27) \
+ _(x28) _(x29) _(x2a) _(x2b) _(x2c) _(x2d) _(x2e) _(x2f) \
+ _(x30) _(x31) _(x32) _(x33) _(x34) _(x35) _(x36) _(x37) \
+ _(x38) _(x39) _(x3a) _(x3b) _(x3c) _(x3d) _(x3e) _(x3f)
+
+#define DECL(x) extern const int x;
+XCHG(DECL)
+extern const int nop;
+
+static const int *x[] = {
+#define SLOT(x) &x,
+ XCHG(SLOT)
+};
+
+extern void call_example(const int *f, struct regs *r);
+
+static const char *prog = "???";
+
+__attribute__((format(printf, 1, 2), noreturn))
+static void barf(const char *m, ...)
+{
+ va_list ap;
+
+ va_start(ap, m);
+ fprintf(stderr, "%s: ", prog);
+ vfprintf(stderr, m, ap);
+ putc('\n', stderr);
+ va_end(ap);
+ exit(127);
+}
+
+static void *xmalloc(size_t sz)
+{
+ void *p;
+
+ if (!sz) return (0);
+ p = malloc(sz);
+ if (!p) barf("malloc failed");
+ return (p);
+}
+
+#define DEF_PARSEINT(name, ty, strto) \
+ static ty parse_##name(const char *what, const char *p, ty min, ty max) \
+ { \
+ const char *pp = p; \
+ char *q; \
+ ty i; \
+ int err; \
+ \
+ if (ISSPACE(*p)) goto bad; \
+ err = errno; errno = 0; \
+ i = strto(p, &q, 0); \
+ if (errno) goto bad; \
+ if (*q) goto bad; \
+ if (i < min || i > max) goto bad; \
+ errno = err; \
+ return (i); \
+ \
+ bad: \
+ barf("bad %s `%s'", what, pp); \
+ }
+DEF_PARSEINT(long, long, strtol)
+DEF_PARSEINT(ulong, unsigned long, strtoul)
+
+static int hex_digit(char ch)
+{
+ if ('0' <= ch && ch <= '9') return (ch - '0');
+ else if ('A' <= ch && ch <= 'F') return (ch - 'A' + 10);
+ else if ('a' <= ch && ch <= 'f') return (ch - 'a' + 10);
+ else return (-1);
+}
+
+static void setreg(union reg *r,
+ struct seg **seg_inout,
+ int *i_inout, int argc, char *argv[])
+{
+ struct seg *seg;
+ const char *p, *pp;
+ unsigned char *q;
+ int hi, lo;
+ size_t n;
+
+#define LONG_REG(p) (parse_long("signed register", (p), LONG_MIN, LONG_MAX))
+#define ULONG_REG(p) (parse_ulong("unsigned register", (p), 0, ULONG_MAX))
+
+ p = *i_inout >= argc ? "-" : argv[(*i_inout)++];
+ switch (*p) {
+ case '-':
+ if (p[1]) r->i = LONG_REG(p);
+ else r->u = 0xdeadbeefdeadbeef;
+ break;
+ case 'i':
+ if (p[1] != ':') goto bad;
+ r->i = LONG_REG(p + 2);
+ break;
+ case 'u':
+ if (p[1] != ':') goto bad;
+ r->u = ULONG_REG(p + 2);
+ break;
+ case 'c':
+ if (p[1] != ':' || p[3]) goto bad;
+ r->u = p[2];
+ break;
+ case 's':
+ if (p[1] != ':') goto bad;
+ pp = p + 2; n = strlen(pp) + 1;
+ seg = (*seg_inout)++; seg->p = xmalloc(n); seg->sz = n;
+ memcpy(seg->p, pp, n); r->p = seg->p;
+ break;
+ case 'm':
+ if (p[1] != ':') goto bad;
+ pp = p + 2; n = strlen(pp); if (n%2) goto bad;
+ seg = (*seg_inout)++; seg->p = q = xmalloc(n/2); seg->sz = n/2;
+ while (n) {
+ hi = hex_digit(pp[0]); lo = hex_digit(pp[1]);
+ if (hi < 0 || lo < 0) goto bad;
+ *q++ = 16*hi + lo; n -= 2; pp += 2;
+ }
+ r->p = seg->p;
+ break;
+ default:
+ if (ISDIGIT(*p)) r->u = ULONG_REG(p);
+ else if (*p == '+') r->i = LONG_REG(p);
+ else if (*p == '\'' && p[2] == '\'' && !p[3]) r->u = p[1];
+ else goto bad;
+ break;
+ bad:
+ barf("bad regspec `%s'", p);
+ }
+
+#undef LONG_REG
+#undef ULONG_REG
+}
+
+static void dumpreg(const char *name, const union reg *r,
+ const struct seg *seg, size_t nseg)
+{
+ size_t i;
+
+ printf("%3s = 0x%016lx = %20ld = %20lu", name, r->u, r->i, r->u);
+ if (r->u >= ' ' && r->u <= '~') printf(" = '%c'", (int)r->u);
+ for (i = 0; i < nseg; i++) {
+ if (r->p == seg[i].p)
+ printf(" = seg[%zu] base", i);
+ else if (r->p == seg[i].p + seg[i].sz)
+ printf(" = seg[%zu] limit", i);
+ else if (seg[i].p < r->p && r->p < seg[i].p + seg[i].sz)
+ printf(" = seg[%zu] + %zu", i, (size_t)(r->p - seg[i].p));
+ }
+ putchar('\n');
+}
+
+static void dumpseg(const struct seg *seg)
+{
+ size_t i, j;
+ unsigned char ch;
+
+ for (i = 0; i < seg->sz; i += 8) {
+ printf("\t%8zx :", i);
+ for (j = 0; j < 8; j++)
+ if (i + j >= seg->sz) printf(" **");
+ else printf(" %02x", seg->p[i + j]);
+ printf(" : ");
+ for (j = 0; j < 8; j++)
+ if (i + j >= seg->sz) putchar('*');
+ else {
+ ch = seg->p[i + j];
+ if (' ' <= ch && ch <= '~') putchar(ch);
+ else putchar('.');
+ }
+ putchar('\n');
+ }
+}
+
+int main(int argc, char *argv[])
+{
+ struct regs r;
+ struct seg seg[16], *segp = seg;
+ size_t nseg;
+ int i, j;
+
+ prog = strrchr(argv[0], '/'); if (prog) prog++; else prog = argv[0];
+
+ if (argc < 2)
+ barf("usage: %s I [A B C D SI DI BP R8 R9 R10 R11 R12 R13 R14 R15 F]",
+ prog);
+
+ j = parse_long("program index", argv[1], -1, N(x) - 1);
+
+ i = 2;
+ setreg(&r.a, &segp, &i, argc, argv);
+ setreg(&r.b, &segp, &i, argc, argv);
+ setreg(&r.c, &segp, &i, argc, argv);
+ setreg(&r.d, &segp, &i, argc, argv);
+ setreg(&r.si, &segp, &i, argc, argv);
+ setreg(&r.di, &segp, &i, argc, argv);
+ setreg(&r.bp, &segp, &i, argc, argv);
+ setreg(&r.r8, &segp, &i, argc, argv);
+ setreg(&r.r9, &segp, &i, argc, argv);
+ setreg(&r.r10, &segp, &i, argc, argv);
+ setreg(&r.r11, &segp, &i, argc, argv);
+ setreg(&r.r12, &segp, &i, argc, argv);
+ setreg(&r.r13, &segp, &i, argc, argv);
+ setreg(&r.r14, &segp, &i, argc, argv);
+ setreg(&r.r15, &segp, &i, argc, argv);
+ setreg(&r.f, &segp, &i, argc, argv);
+ nseg = segp - seg;
+
+ call_example(j < 0 ? &nop : x[j], &r);
+
+ dumpreg("rax", &r.a, seg, nseg);
+ dumpreg("rbx", &r.b, seg, nseg);
+ dumpreg("rcx", &r.c, seg, nseg);
+ dumpreg("rdx", &r.d, seg, nseg);
+ dumpreg("rsi", &r.si, seg, nseg);
+ dumpreg("rdi", &r.di, seg, nseg);
+ dumpreg("rbp", &r.bp, seg, nseg);
+ dumpreg("rbp", &r.bp, seg, nseg);
+ dumpreg("r8", &r.r8, seg, nseg);
+ dumpreg("r9", &r.r9, seg, nseg);
+ dumpreg("r10", &r.r10, seg, nseg);
+ dumpreg("r11", &r.r11, seg, nseg);
+ dumpreg("r12", &r.r12, seg, nseg);
+ dumpreg("r13", &r.r13, seg, nseg);
+ dumpreg("r14", &r.r14, seg, nseg);
+ dumpreg("r15", &r.r15, seg, nseg);
+
+#define CF (1 << 0)
+#define PF (1 << 2)
+#define ZF (1 << 6)
+#define SF (1 << 7)
+#define OF (1 << 11)
+
+ dumpreg("f", &r.f, seg, nseg);
+ printf("\tstatus: %ccf %cpf %caf %czf %csf %cdf %cof\n",
+ (r.f.u >> 0)&1u ? '+' : '-',
+ (r.f.u >> 2)&1u ? '+' : '-',
+ (r.f.u >> 4)&1u ? '+' : '-',
+ (r.f.u >> 6)&1u ? '+' : '-',
+ (r.f.u >> 7)&1u ? '+' : '-',
+ (r.f.u >> 10)&1u ? '+' : '-',
+ (r.f.u >> 11)&1u ? '+' : '-');
+ printf("\tcond:");
+ if (r.f.u&CF) printf(" c/b/nae"); else printf(" nc/ae/nb");
+ if (r.f.u&ZF) printf(" e/z"); else printf(" ne/nz");
+ if (r.f.u&SF) printf(" s"); else printf(" ns");
+ if (r.f.u&OF) printf(" o"); else printf(" no");
+ if (r.f.u&PF) printf(" p"); else printf(" np");
+ if ((r.f.u&CF) || (r.f.u&ZF)) printf(" be/na"); else printf(" a/nbe");
+ if (!(r.f.u&OF) == !(r.f.u&SF)) printf(" ge/nl"); else printf(" l/nge");
+ if (!(r.f.u&OF) == !(r.f.u&SF) && !(r.f.u&ZF))
+ printf(" g/nle"); else printf(" le/ng");
+ putchar('\n');
+ printf("\tsystem: %ctf %cif iopl=%d %cnt "
+ "%crf %cvm %cac %cvif %cvip %cid\n",
+ (r.f.u >> 8)&1u ? '+' : '-',
+ (r.f.u >> 9)&1u ? '+' : '-',
+ (int)((r.f.u >> 12)&1u),
+ (r.f.u >> 14)&1u ? '+' : '-',
+ (r.f.u >> 16)&1u ? '+' : '-',
+ (r.f.u >> 17)&1u ? '+' : '-',
+ (r.f.u >> 18)&1u ? '+' : '-',
+ (r.f.u >> 19)&1u ? '+' : '-',
+ (r.f.u >> 20)&1u ? '+' : '-',
+ (r.f.u >> 21)&1u ? '+' : '-');
+
+#undef CF
+#undef PF
+#undef ZF
+#undef SF
+#undef OF
+
+ for (i = 0; i < nseg; i++)
+ { printf("seg[%d] (%p):\n", i, seg[i].p); dumpseg(&seg[i]); }
+
+ return (0);
+}
~mdw / xchg-rax-rax / commitdiff