ndisasm.c

   1 /* ndisasm.c   the Netwide Disassembler main module
   2  *
   3  * The Netwide Assembler is copyright (C) 1996 Simon Tatham and
   4  * Julian Hall. All rights reserved. The software is
   5  * redistributable under the licence given in the file "Licence"
   6  * distributed in the NASM archive.
   7  */
   8
   9 #include <stdio.h>
  10 #include <stdarg.h>
  11 #include <stdlib.h>
  12 #include <string.h>
  13 #include <ctype.h>
  14 #include <errno.h>
  15 #include <inttypes.h>
  16
  17 #include "insns.h"
  18 #include "nasm.h"
  19 #include "nasmlib.h"
  20 #include "sync.h"
  21 #include "disasm.h"
  22
  23 #define BPL 8                   /* bytes per line of hex dump */
  24
  25 static const char *help =
  26     "usage: ndisasm [-a] [-i] [-h] [-r] [-u] [-b bits] [-o origin] [-s sync...]\n"
  27     "               [-e bytes] [-k start,bytes] [-p vendor] file\n"
  28     "   -a or -i activates auto (intelligent) sync\n"
  29     "   -u same as -b 32\n"
  30     "   -b 16, -b 32 or -b 64 sets the processor mode\n"
  31     "   -h displays this text\n"
  32     "   -r or -v displays the version number\n"
  33     "   -e skips <bytes> bytes of header\n"
  34     "   -k avoids disassembling <bytes> bytes from position <start>\n"
  35     "   -p selects the preferred vendor instruction set (intel, amd, cyrix, idt)\n";
  36
  37 static void output_ins(uint32_t, uint8_t *, int, char *);
  38 static void skip(uint32_t dist, FILE * fp);
  39
  40 static void ndisasm_error(int severity, const char *fmt, ...)
  41 {
  42     va_list va;
  43
  44     va_start(va, fmt);
  45     vfprintf(stderr, fmt, va);
  46
  47     if (severity & ERR_FATAL)
  48         exit(1);
  49 }
  50
  51 int main(int argc, char **argv)
  52 {
  53     char buffer[INSN_MAX * 2], *p, *ep, *q;
  54     char outbuf[256];
  55     char *pname = *argv;
  56     char *filename = NULL;
  57     uint32_t nextsync, synclen, initskip = 0L;
  58     int lenread;
  59     int32_t lendis;
  60     int autosync = FALSE;
  61     int bits = 16, b;
  62     int eof = FALSE;
  63     uint32_t prefer = 0;
  64     int rn_error;
  65     int32_t offset;
  66     FILE *fp;
  67
  68     nasm_set_malloc_error(ndisasm_error);
  69
  70     offset = 0;
  71     init_sync();
  72
  73     while (--argc) {
  74         char *v, *vv, *p = *++argv;
  75         if (*p == '-' && p[1]) {
  76             p++;
  77             while (*p)
  78                 switch (tolower(*p)) {
  79                 case 'a':      /* auto or intelligent sync */
  80                 case 'i':
  81                     autosync = TRUE;
  82                     p++;
  83                     break;
  84                 case 'h':
  85                     fprintf(stderr, help);
  86                     return 0;
  87                 case 'r':
  88                 case 'v':
  89                     fprintf(stderr,
  90                             "NDISASM version %s compiled " __DATE__ "\n",
  91                             NASM_VER);
  92                     return 0;
  93                 case 'u':       /* -u for -b 32, -uu for -b 64 */
  94                     if (bits < 64)
  95                         bits <<= 1;
  96                     p++;
  97                     break;
  98                 case 'b':      /* bits */
  99                     v = p[1] ? p + 1 : --argc ? *++argv : NULL;
 100                     if (!v) {
 101                         fprintf(stderr, "%s: `-b' requires an argument\n",
 102                                 pname);
 103                         return 1;
 104                     }
 105                     b = strtoul(v, &ep, 10);
 106                     if (*ep || !(bits == 16 || bits == 32 || bits == 64)) {
 107                         fprintf(stderr, "%s: argument to `-b' should"
 108                                 " be 16, 32 or 64\n", pname);
 109                     } else {
 110                         bits = b;
 111                     }
 112                     p = "";     /* force to next argument */
 113                     break;
 114                 case 'o':      /* origin */
 115                     v = p[1] ? p + 1 : --argc ? *++argv : NULL;
 116                     if (!v) {
 117                         fprintf(stderr, "%s: `-o' requires an argument\n",
 118                                 pname);
 119                         return 1;
 120                     }
 121                     offset = readnum(v, &rn_error);
 122                     if (rn_error) {
 123                         fprintf(stderr,
 124                                 "%s: `-o' requires a numeric argument\n",
 125                                 pname);
 126                         return 1;
 127                     }
 128                     p = "";     /* force to next argument */
 129                     break;
 130                 case 's':      /* sync point */
 131                     v = p[1] ? p + 1 : --argc ? *++argv : NULL;
 132                     if (!v) {
 133                         fprintf(stderr, "%s: `-s' requires an argument\n",
 134                                 pname);
 135                         return 1;
 136                     }
 137                     add_sync(readnum(v, &rn_error), 0L);
 138                     if (rn_error) {
 139                         fprintf(stderr,
 140                                 "%s: `-s' requires a numeric argument\n",
 141                                 pname);
 142                         return 1;
 143                     }
 144                     p = "";     /* force to next argument */
 145                     break;
 146                 case 'e':      /* skip a header */
 147                     v = p[1] ? p + 1 : --argc ? *++argv : NULL;
 148                     if (!v) {
 149                         fprintf(stderr, "%s: `-e' requires an argument\n",
 150                                 pname);
 151                         return 1;
 152                     }
 153                     initskip = readnum(v, &rn_error);
 154                     if (rn_error) {
 155                         fprintf(stderr,
 156                                 "%s: `-e' requires a numeric argument\n",
 157                                 pname);
 158                         return 1;
 159                     }
 160                     p = "";     /* force to next argument */
 161                     break;
 162                 case 'k':      /* skip a region */
 163                     v = p[1] ? p + 1 : --argc ? *++argv : NULL;
 164                     if (!v) {
 165                         fprintf(stderr, "%s: `-k' requires an argument\n",
 166                                 pname);
 167                         return 1;
 168                     }
 169                     vv = strchr(v, ',');
 170                     if (!vv) {
 171                         fprintf(stderr,
 172                                 "%s: `-k' requires two numbers separated"
 173                                 " by a comma\n", pname);
 174                         return 1;
 175                     }
 176                     *vv++ = '\0';
 177                     nextsync = readnum(v, &rn_error);
 178                     if (rn_error) {
 179                         fprintf(stderr,
 180                                 "%s: `-k' requires numeric arguments\n",
 181                                 pname);
 182                         return 1;
 183                     }
 184                     synclen = readnum(vv, &rn_error);
 185                     if (rn_error) {
 186                         fprintf(stderr,
 187                                 "%s: `-k' requires numeric arguments\n",
 188                                 pname);
 189                         return 1;
 190                     }
 191                     add_sync(nextsync, synclen);
 192                     p = "";     /* force to next argument */
 193                     break;
 194                 case 'p':      /* preferred vendor */
 195                     v = p[1] ? p + 1 : --argc ? *++argv : NULL;
 196                     if (!v) {
 197                         fprintf(stderr, "%s: `-p' requires an argument\n",
 198                                 pname);
 199                         return 1;
 200                     }
 201                     if (!strcmp(v, "intel")) {
 202                         prefer = 0;     /* Default */
 203                     } else if (!strcmp(v, "amd")) {
 204                         prefer = IF_AMD | IF_3DNOW;
 205                     } else if (!strcmp(v, "cyrix")) {
 206                         prefer = IF_CYRIX | IF_3DNOW;
 207                     } else if (!strcmp(v, "idt") || !strcmp(v, "centaur")
 208                                || !strcmp(v, "winchip")) {
 209                         prefer = IF_3DNOW;
 210                     } else {
 211                         fprintf(stderr,
 212                                 "%s: unknown vendor `%s' specified with `-p'\n",
 213                                 pname, v);
 214                         return 1;
 215                     }
 216                     p = "";     /* force to next argument */
 217                     break;
 218                 default:       /*bf */
 219                     fprintf(stderr, "%s: unrecognised option `-%c'\n",
 220                             pname, *p);
 221                     return 1;
 222                 }
 223         } else if (!filename) {
 224             filename = p;
 225         } else {
 226             fprintf(stderr, "%s: more than one filename specified\n",
 227                     pname);
 228             return 1;
 229         }
 230     }
 231
 232     if (!filename) {
 233         fprintf(stderr, help, pname);
 234         return 0;
 235     }
 236
 237     if (strcmp(filename, "-")) {
 238         fp = fopen(filename, "rb");
 239         if (!fp) {
 240             fprintf(stderr, "%s: unable to open `%s': %s\n",
 241                     pname, filename, strerror(errno));
 242             return 1;
 243         }
 244     } else
 245         fp = stdin;
 246
 247     if (initskip > 0)
 248         skip(initskip, fp);
 249
 250     /*
 251      * This main loop is really horrible, and wants rewriting with
 252      * an axe. It'll stay the way it is for a while though, until I
 253      * find the energy...
 254      */
 255
 256     p = q = buffer;
 257     nextsync = next_sync(offset, &synclen);
 258     do {
 259         uint32_t to_read = buffer + sizeof(buffer) - p;
 260         if (to_read > nextsync - offset - (p - q))
 261             to_read = nextsync - offset - (p - q);
 262         if (to_read) {
 263             lenread = fread(p, 1, to_read, fp);
 264             if (lenread == 0)
 265                 eof = TRUE;     /* help along systems with bad feof */
 266         } else
 267             lenread = 0;
 268         p += lenread;
 269         if ((uint32_t)offset == nextsync) {
 270             if (synclen) {
 271                 fprintf(stdout, "%08"PRIX32"  skipping 0x%"PRIX32" bytes\n", offset, synclen);
 272                 offset += synclen;
 273                 skip(synclen, fp);
 274             }
 275             p = q = buffer;
 276             nextsync = next_sync(offset, &synclen);
 277         }
 278         while (p > q && (p - q >= INSN_MAX || lenread == 0)) {
 279             lendis =
 280                 disasm(q, outbuf, sizeof(outbuf), bits, offset, autosync,
 281                        prefer);
 282             if (!lendis || lendis > (p - q)
 283                 || (uint32_t)lendis > nextsync - offset)
 284                 lendis = eatbyte(q, outbuf, sizeof(outbuf));
 285             output_ins(offset, q, lendis, outbuf);
 286             q += lendis;
 287             offset += lendis;
 288         }
 289         if (q >= buffer + INSN_MAX) {
 290             uint8_t *r = buffer, *s = q;
 291             int count = p - q;
 292             while (count--)
 293                 *r++ = *s++;
 294             p -= (q - buffer);
 295             q = buffer;
 296         }
 297     } while (lenread > 0 || !(eof || feof(fp)));
 298
 299     if (fp != stdin)
 300         fclose(fp);
 301
 302     return 0;
 303 }
 304
 305 static void output_ins(uint32_t offset, uint8_t *data,
 306                        int datalen, char *insn)
 307 {
 308     int bytes;
 309     fprintf(stdout, "%08"PRIX32"  ", offset);
 310
 311     bytes = 0;
 312     while (datalen > 0 && bytes < BPL) {
 313         fprintf(stdout, "%02X", *data++);
 314         bytes++;
 315         datalen--;
 316     }
 317
 318     fprintf(stdout, "%*s%s\n", (BPL + 1 - bytes) * 2, "", insn);
 319
 320     while (datalen > 0) {
 321         fprintf(stdout, "         -");
 322         bytes = 0;
 323         while (datalen > 0 && bytes < BPL) {
 324             fprintf(stdout, "%02X", *data++);
 325             bytes++;
 326             datalen--;
 327         }
 328         fprintf(stdout, "\n");
 329     }
 330 }
 331
 332 /*
 333  * Skip a certain amount of data in a file, either by seeking if
 334  * possible, or if that fails then by reading and discarding.
 335  */
 336 static void skip(uint32_t dist, FILE * fp)
 337 {
 338     char buffer[256];           /* should fit on most stacks :-) */
 339
 340     /*
 341      * Got to be careful with fseek: at least one fseek I've tried
 342      * doesn't approve of SEEK_CUR. So I'll use SEEK_SET and
 343      * ftell... horrible but apparently necessary.
 344      */
 345     if (fseek(fp, dist + ftell(fp), SEEK_SET)) {
 346         while (dist > 0) {
 347             uint32_t len = (dist < sizeof(buffer) ?
 348                                  dist : sizeof(buffer));
 349             if (fread(buffer, 1, len, fp) < len) {
 350                 perror("fread");
 351                 exit(1);
 352             }
 353             dist -= len;
 354         }
 355     }
 356 }