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