listing.c

   1 /* listing.c    listing file generator for the Netwide Assembler
   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  * initial version 2/vii/97 by Simon Tatham
   9  */
  10
  11 #include "compiler.h"
  12
  13 #include <stdio.h>
  14 #include <stdlib.h>
  15 #include <stddef.h>
  16 #include <string.h>
  17 #include <ctype.h>
  18 #include <inttypes.h>
  19
  20 #include "nasm.h"
  21 #include "nasmlib.h"
  22 #include "listing.h"
  23
  24 #define LIST_MAX_LEN 216        /* something sensible */
  25 #define LIST_INDENT  40
  26 #define LIST_HEXBIT  18
  27
  28 typedef struct MacroInhibit MacroInhibit;
  29
  30 static struct MacroInhibit {
  31     MacroInhibit *next;
  32     int level;
  33     int inhibiting;
  34 } *mistack;
  35
  36 static char xdigit[] = "0123456789ABCDEF";
  37
  38 #define HEX(a,b) (*(a)=xdigit[((b)>>4)&15],(a)[1]=xdigit[(b)&15]);
  39
  40 static char listline[LIST_MAX_LEN];
  41 static int listlinep;
  42
  43 static char listdata[2 * LIST_INDENT];  /* we need less than that actually */
  44 static int32_t listoffset;
  45
  46 static int32_t listlineno;
  47
  48 static int32_t listp;
  49
  50 static int suppress;            /* for INCBIN & TIMES special cases */
  51
  52 static int listlevel, listlevel_e;
  53
  54 static FILE *listfp;
  55
  56 static void list_emit(void)
  57 {
  58     if (!listlinep && !listdata[0])
  59         return;
  60
  61     fprintf(listfp, "%6"PRId32" ", ++listlineno);
  62
  63     if (listdata[0])
  64         fprintf(listfp, "%08"PRIX32" %-*s", listoffset, LIST_HEXBIT + 1,
  65                 listdata);
  66     else
  67         fprintf(listfp, "%*s", LIST_HEXBIT + 10, "");
  68
  69     if (listlevel_e)
  70         fprintf(listfp, "%s<%d>", (listlevel < 10 ? " " : ""),
  71                 listlevel_e);
  72     else if (listlinep)
  73         fprintf(listfp, "    ");
  74
  75     if (listlinep)
  76         fprintf(listfp, " %s", listline);
  77
  78     putc('\n', listfp);
  79     listlinep = false;
  80     listdata[0] = '\0';
  81 }
  82
  83 static void list_init(char *fname, efunc error)
  84 {
  85     listfp = fopen(fname, "w");
  86     if (!listfp) {
  87         error(ERR_NONFATAL, "unable to open listing file `%s'", fname);
  88         return;
  89     }
  90
  91     *listline = '\0';
  92     listlineno = 0;
  93     listp = true;
  94     listlevel = 0;
  95     suppress = 0;
  96     mistack = nasm_malloc(sizeof(MacroInhibit));
  97     mistack->next = NULL;
  98     mistack->level = 0;
  99     mistack->inhibiting = true;
 100 }
 101
 102 static void list_cleanup(void)
 103 {
 104     if (!listp)
 105         return;
 106
 107     while (mistack) {
 108         MacroInhibit *temp = mistack;
 109         mistack = temp->next;
 110         nasm_free(temp);
 111     }
 112
 113     list_emit();
 114     fclose(listfp);
 115 }
 116
 117 static void list_out(int32_t offset, char *str)
 118 {
 119     if (strlen(listdata) + strlen(str) > LIST_HEXBIT) {
 120         strcat(listdata, "-");
 121         list_emit();
 122     }
 123     if (!listdata[0])
 124         listoffset = offset;
 125     strcat(listdata, str);
 126 }
 127
 128 static void list_output(int32_t offset, const void *data,
 129                         enum out_type type, uint64_t size)
 130 {
 131     if (!listp || suppress || user_nolist)      /* fbk - 9/2/00 */
 132         return;
 133
 134     switch (type) {
 135     case OUT_RAWDATA:
 136     {
 137         uint8_t const *p = data;
 138         char q[3];
 139         while (size--) {
 140             HEX(q, *p);
 141             q[2] = '\0';
 142             list_out(offset++, q);
 143             p++;
 144         }
 145         break;
 146     }
 147     case OUT_ADDRESS:
 148     {
 149         uint64_t d = *(int64_t *)data;
 150         char q[20];
 151         uint8_t p[8], *r = p;
 152         if (size == 4) {
 153             q[0] = '[';
 154             q[9] = ']';
 155             q[10] = '\0';
 156             WRITELONG(r, d);
 157             HEX(q + 1, p[0]);
 158             HEX(q + 3, p[1]);
 159             HEX(q + 5, p[2]);
 160             HEX(q + 7, p[3]);
 161             list_out(offset, q);
 162         } else if (size == 8) {
 163             q[0] = '[';
 164             q[17] = ']';
 165             q[18] = '\0';
 166             WRITEDLONG(r, d);
 167             HEX(q + 1,  p[0]);
 168             HEX(q + 3,  p[1]);
 169             HEX(q + 5,  p[2]);
 170             HEX(q + 7,  p[3]);
 171             HEX(q + 9,  p[4]);
 172             HEX(q + 11, p[5]);
 173             HEX(q + 13, p[6]);
 174             HEX(q + 15, p[7]);
 175             list_out(offset, q);
 176         } else {
 177             q[0] = '[';
 178             q[5] = ']';
 179             q[6] = '\0';
 180             WRITESHORT(r, d);
 181             HEX(q + 1, p[0]);
 182             HEX(q + 3, p[1]);
 183             list_out(offset, q);
 184         }
 185         break;
 186     }
 187     case OUT_REL2ADR:
 188     {
 189         uint32_t d = *(int32_t *)data;
 190         char q[11];
 191         uint8_t p[4], *r = p;
 192         q[0] = '(';
 193         q[5] = ')';
 194         q[6] = '\0';
 195         WRITESHORT(r, d);
 196         HEX(q + 1, p[0]);
 197         HEX(q + 3, p[1]);
 198         list_out(offset, q);
 199         break;
 200     }
 201     case OUT_REL4ADR:
 202     {
 203         uint32_t d = *(int32_t *)data;
 204         char q[11];
 205         uint8_t p[4], *r = p;
 206         q[0] = '(';
 207         q[9] = ')';
 208         q[10] = '\0';
 209         WRITELONG(r, d);
 210         HEX(q + 1, p[0]);
 211         HEX(q + 3, p[1]);
 212         HEX(q + 5, p[2]);
 213         HEX(q + 7, p[3]);
 214         list_out(offset, q);
 215         break;
 216     }
 217     case OUT_REL8ADR:
 218     {
 219         uint64_t d = *(int64_t *)data;
 220         char q[19];
 221         uint8_t p[4], *r = p;
 222         q[0] = '(';
 223         q[17] = ')';
 224         q[18] = '\0';
 225         WRITEDLONG(r, d);
 226         HEX(q + 1, p[0]);
 227         HEX(q + 3, p[1]);
 228         HEX(q + 5, p[2]);
 229         HEX(q + 7, p[3]);
 230         HEX(q + 9, p[4]);
 231         HEX(q + 11, p[5]);
 232         HEX(q + 13, p[6]);
 233         HEX(q + 15, p[7]);
 234         list_out(offset, q);
 235         break;
 236     }
 237     case OUT_RESERVE:
 238     {
 239         char q[20];
 240         snprintf(q, sizeof(q), "<res %08"PRIX64">", size);
 241         list_out(offset, q);
 242         break;
 243     }
 244     }
 245 }
 246
 247 static void list_line(int type, char *line)
 248 {
 249     if (!listp)
 250         return;
 251     if (user_nolist) {          /* fbk - 9/2/00 */
 252         listlineno++;
 253         return;
 254     }
 255
 256     if (mistack && mistack->inhibiting) {
 257         if (type == LIST_MACRO)
 258             return;
 259         else {                  /* pop the m i stack */
 260             MacroInhibit *temp = mistack;
 261             mistack = temp->next;
 262             nasm_free(temp);
 263         }
 264     }
 265     list_emit();
 266     listlinep = true;
 267     strncpy(listline, line, LIST_MAX_LEN - 1);
 268     listline[LIST_MAX_LEN - 1] = '\0';
 269     listlevel_e = listlevel;
 270 }
 271
 272 static void list_uplevel(int type)
 273 {
 274     if (!listp)
 275         return;
 276     if (type == LIST_INCBIN || type == LIST_TIMES) {
 277         suppress |= (type == LIST_INCBIN ? 1 : 2);
 278         list_out(listoffset, type == LIST_INCBIN ? "<incbin>" : "<rept>");
 279         return;
 280     }
 281
 282     listlevel++;
 283
 284     if (mistack && mistack->inhibiting && type == LIST_INCLUDE) {
 285         MacroInhibit *temp = nasm_malloc(sizeof(MacroInhibit));
 286         temp->next = mistack;
 287         temp->level = listlevel;
 288         temp->inhibiting = false;
 289         mistack = temp;
 290     } else if (type == LIST_MACRO_NOLIST) {
 291         MacroInhibit *temp = nasm_malloc(sizeof(MacroInhibit));
 292         temp->next = mistack;
 293         temp->level = listlevel;
 294         temp->inhibiting = true;
 295         mistack = temp;
 296     }
 297 }
 298
 299 static void list_downlevel(int type)
 300 {
 301     if (!listp)
 302         return;
 303
 304     if (type == LIST_INCBIN || type == LIST_TIMES) {
 305         suppress &= ~(type == LIST_INCBIN ? 1 : 2);
 306         return;
 307     }
 308
 309     listlevel--;
 310     while (mistack && mistack->level > listlevel) {
 311         MacroInhibit *temp = mistack;
 312         mistack = temp->next;
 313         nasm_free(temp);
 314     }
 315 }
 316
 317 ListGen nasmlist = {
 318     list_init,
 319     list_cleanup,
 320     list_output,
 321     list_line,
 322     list_uplevel,
 323     list_downlevel
 324 };