asm/listing.c

   1 /* ----------------------------------------------------------------------- *
   2  *
   3  *   Copyright 1996-2018 The NASM Authors - All Rights Reserved
   4  *   See the file AUTHORS included with the NASM distribution for
   5  *   the specific copyright holders.
   6  *
   7  *   Redistribution and use in source and binary forms, with or without
   8  *   modification, are permitted provided that the following
   9  *   conditions are met:
  10  *
  11  *   * Redistributions of source code must retain the above copyright
  12  *     notice, this list of conditions and the following disclaimer.
  13  *   * Redistributions in binary form must reproduce the above
  14  *     copyright notice, this list of conditions and the following
  15  *     disclaimer in the documentation and/or other materials provided
  16  *     with the distribution.
  17  *
  18  *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
  19  *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
  20  *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  21  *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  22  *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
  23  *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  24  *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  25  *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  26  *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  27  *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  28  *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  29  *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
  30  *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  31  *
  32  * ----------------------------------------------------------------------- */
  33
  34 /*
  35  * listing.c    listing file generator for the Netwide Assembler
  36  */
  37
  38 #include "compiler.h"
  39
  40 #include "nctype.h"
  41
  42 #include "nasm.h"
  43 #include "nasmlib.h"
  44 #include "error.h"
  45 #include "strlist.h"
  46 #include "listing.h"
  47
  48 #define LIST_MAX_LEN 1024       /* something sensible */
  49 #define LIST_INDENT  40
  50 #define LIST_HEXBIT  18
  51
  52 typedef struct MacroInhibit MacroInhibit;
  53
  54 static struct MacroInhibit {
  55     MacroInhibit *next;
  56     int level;
  57     int inhibiting;
  58 } *mistack;
  59
  60 static const char xdigit[] = "0123456789ABCDEF";
  61
  62 #define HEX(a,b) (*(a)=xdigit[((b)>>4)&15],(a)[1]=xdigit[(b)&15]);
  63
  64 static char listline[LIST_MAX_LEN];
  65 static bool listlinep;
  66
  67 struct strlist *list_errors;
  68
  69 static char listdata[2 * LIST_INDENT];  /* we need less than that actually */
  70 static int32_t listoffset;
  71
  72 static int32_t listlineno;
  73
  74 static int32_t listp;
  75
  76 static int suppress;            /* for INCBIN & TIMES special cases */
  77
  78 static int listlevel, listlevel_e;
  79
  80 static FILE *listfp;
  81
  82 static void list_emit(void)
  83 {
  84     int i;
  85     const struct strlist_entry *e;
  86
  87     if (listlinep || *listdata) {
  88         fprintf(listfp, "%6"PRId32" ", listlineno);
  89
  90         if (listdata[0])
  91             fprintf(listfp, "%08"PRIX32" %-*s", listoffset, LIST_HEXBIT + 1,
  92                     listdata);
  93         else
  94             fprintf(listfp, "%*s", LIST_HEXBIT + 10, "");
  95
  96         if (listlevel_e)
  97             fprintf(listfp, "%s<%d>", (listlevel < 10 ? " " : ""),
  98                     listlevel_e);
  99         else if (listlinep)
 100             fprintf(listfp, "    ");
 101
 102         if (listlinep)
 103             fprintf(listfp, " %s", listline);
 104
 105         putc('\n', listfp);
 106         listlinep = false;
 107         listdata[0] = '\0';
 108     }
 109
 110     if (list_errors) {
 111         strlist_for_each(e, list_errors) {
 112             fprintf(listfp, "%6"PRId32"          ", listlineno);
 113             for (i = 0; i < LIST_HEXBIT; i++)
 114                 putc('*', listfp);
 115
 116             if (listlevel_e)
 117                 fprintf(listfp, " %s<%d>", (listlevel < 10 ? " " : ""),
 118                         listlevel_e);
 119             else
 120                 fprintf(listfp, "     ");
 121
 122             fprintf(listfp, "  %s\n", e->str);
 123         }
 124
 125         strlist_free(&list_errors);
 126     }
 127 }
 128
 129 static void list_init(const char *fname)
 130 {
 131     if (!fname || fname[0] == '\0') {
 132         listfp = NULL;
 133         return;
 134     }
 135
 136     listfp = nasm_open_write(fname, NF_TEXT);
 137     if (!listfp) {
 138         nasm_nonfatal("unable to open listing file `%s'", fname);
 139         return;
 140     }
 141
 142     *listline = '\0';
 143     listlineno = 0;
 144     list_errors = NULL;
 145     listp = true;
 146     listlevel = 0;
 147     suppress = 0;
 148     mistack = nasm_malloc(sizeof(MacroInhibit));
 149     mistack->next = NULL;
 150     mistack->level = 0;
 151     mistack->inhibiting = true;
 152 }
 153
 154 static void list_cleanup(void)
 155 {
 156     if (!listp)
 157         return;
 158
 159     while (mistack) {
 160         MacroInhibit *temp = mistack;
 161         mistack = temp->next;
 162         nasm_free(temp);
 163     }
 164
 165     list_emit();
 166     fclose(listfp);
 167 }
 168
 169 static void list_out(int64_t offset, char *str)
 170 {
 171     if (strlen(listdata) + strlen(str) > LIST_HEXBIT) {
 172         strcat(listdata, "-");
 173         list_emit();
 174     }
 175     if (!listdata[0])
 176         listoffset = offset;
 177     strcat(listdata, str);
 178 }
 179
 180 static void list_address(int64_t offset, const char *brackets,
 181                          int64_t addr, int size)
 182 {
 183     char q[20];
 184     char *r = q;
 185
 186     nasm_assert(size <= 8);
 187
 188     *r++ = brackets[0];
 189     while (size--) {
 190         HEX(r, addr);
 191         addr >>= 8;
 192         r += 2;
 193     }
 194     *r++ = brackets[1];
 195     *r = '\0';
 196     list_out(offset, q);
 197 }
 198
 199 static void list_output(const struct out_data *data)
 200 {
 201     char q[24];
 202     uint64_t size = data->size;
 203     uint64_t offset = data->offset;
 204     const uint8_t *p = data->data;
 205
 206
 207     if (!listp || suppress || user_nolist)
 208         return;
 209
 210     switch (data->type) {
 211     case OUT_ZERODATA:
 212         if (size > 16) {
 213             snprintf(q, sizeof(q), "<zero %08"PRIX64">", size);
 214             list_out(offset, q);
 215             break;
 216         } else {
 217             p = zero_buffer;
 218         }
 219         /* fall through */
 220     case OUT_RAWDATA:
 221     {
 222         if (size == 0 && !listdata[0])
 223             listoffset = data->offset;
 224         while (size--) {
 225             HEX(q, *p);
 226             q[2] = '\0';
 227             list_out(offset++, q);
 228             p++;
 229         }
 230         break;
 231     }
 232     case OUT_ADDRESS:
 233         list_address(offset, "[]", data->toffset, size);
 234         break;
 235     case OUT_SEGMENT:
 236         q[0] = '[';
 237         memset(q+1, 's', size << 1);
 238         q[(size << 1)+1] = ']';
 239         q[(size << 1)+2] = '\0';
 240         list_out(offset, q);
 241         offset += size;
 242         break;
 243     case OUT_RELADDR:
 244         list_address(offset, "()", data->toffset, size);
 245         break;
 246     case OUT_RESERVE:
 247     {
 248         snprintf(q, sizeof(q), "<res %"PRIX64">", size);
 249         list_out(offset, q);
 250         break;
 251     }
 252     default:
 253         panic();
 254     }
 255 }
 256
 257 static void list_line(int type, char *line)
 258 {
 259     if (!listp)
 260         return;
 261
 262     if (user_nolist)
 263       return;
 264
 265     if (mistack && mistack->inhibiting) {
 266         if (type == LIST_MACRO)
 267             return;
 268         else {                  /* pop the m i stack */
 269             MacroInhibit *temp = mistack;
 270             mistack = temp->next;
 271             nasm_free(temp);
 272         }
 273     }
 274     list_emit();
 275     listlineno = src_get_linnum();
 276     listlinep = true;
 277     strlcpy(listline, line, LIST_MAX_LEN-3);
 278     memcpy(listline + LIST_MAX_LEN-4, "...", 4);
 279     listlevel_e = listlevel;
 280 }
 281
 282 static void mistack_push(bool inhibiting)
 283 {
 284     MacroInhibit *temp = nasm_malloc(sizeof(MacroInhibit));
 285     temp->next = mistack;
 286     temp->level = listlevel;
 287     temp->inhibiting = inhibiting;
 288     mistack = temp;
 289 }
 290
 291 static void list_uplevel(int type, int64_t size)
 292 {
 293     char str[64];
 294
 295     if (!listp)
 296         return;
 297
 298     switch (type) {
 299     case LIST_INCBIN:
 300         suppress |= 1;
 301         snprintf(str, sizeof str, "<bin %"PRIX64">", size);
 302         list_out(listoffset, str);
 303         break;
 304
 305     case LIST_TIMES:
 306         suppress |= 2;
 307         snprintf(str, sizeof str, "<rep %"PRIX64">", size);
 308         list_out(listoffset, str);
 309         break;
 310
 311     case LIST_INCLUDE:
 312         listlevel++;
 313         if (mistack && mistack->inhibiting)
 314             mistack_push(false);
 315         break;
 316
 317     case LIST_MACRO_NOLIST:
 318         listlevel++;
 319         mistack_push(true);
 320         break;
 321
 322     default:
 323         listlevel++;
 324         break;
 325     }
 326 }
 327
 328 static void list_downlevel(int type)
 329 {
 330     if (!listp)
 331         return;
 332
 333     switch (type) {
 334     case LIST_INCBIN:
 335         suppress &= ~1;
 336         break;
 337
 338     case LIST_TIMES:
 339         suppress &= ~2;
 340         break;
 341
 342     default:
 343         listlevel--;
 344         while (mistack && mistack->level > listlevel) {
 345             MacroInhibit *temp = mistack;
 346             mistack = temp->next;
 347             nasm_free(temp);
 348         }
 349         break;
 350     }
 351 }
 352
 353 static void list_error(errflags severity, const char *fmt, ...)
 354 {
 355     va_list ap;
 356
 357     if (!listfp)
 358         return;
 359
 360     if (!list_errors)
 361         list_errors = strlist_alloc(false);
 362
 363     va_start(ap, fmt);
 364     strlist_vprintf(list_errors, fmt, ap);
 365     va_end(ap);
 366
 367     if ((severity & ERR_MASK) >= ERR_FATAL)
 368         list_emit();
 369 }
 370
 371 static void list_set_offset(uint64_t offset)
 372 {
 373     listoffset = offset;
 374 }
 375
 376 static const struct lfmt nasm_list = {
 377     list_init,
 378     list_cleanup,
 379     list_output,
 380     list_line,
 381     list_uplevel,
 382     list_downlevel,
 383     list_error,
 384     list_set_offset
 385 };
 386
 387 const struct lfmt *lfmt = &nasm_list;