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