gas/listing.c

   1 /* listing.c - mainting assembly listings
   2    Copyright (C) 1991, 92, 93, 94, 95, 96, 97, 98, 99, 2000
   3    Free Software Foundation, Inc.
   4
   5 This file is part of GAS, the GNU Assembler.
   6
   7 GAS is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2, or (at your option)
  10 any later version.
  11
  12 GAS is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GAS; see the file COPYING.  If not, write to the Free
  19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  20 02111-1307, USA.  */
  21
  22 /*
  23  Contributed by Steve Chamberlain <sac@cygnus.com>
  24
  25  A listing page looks like:
  26
  27  LISTING_HEADER  sourcefilename pagenumber
  28  TITLE LINE
  29  SUBTITLE LINE
  30  linenumber address data  source
  31  linenumber address data  source
  32  linenumber address data  source
  33  linenumber address data  source
  34
  35  If not overridden, the listing commands are:
  36
  37  .title  "stuff"
  38         Put "stuff" onto the title line
  39  .sbttl  "stuff"
  40         Put stuff onto the subtitle line
  41
  42   If these commands come within 10 lines of the top of the page, they
  43   will affect the page they are on, as well as any subsequent page
  44
  45  .eject
  46         Thow a page
  47  .list
  48         Increment the enable listing counter
  49  .nolist
  50         Decrement the enable listing counter
  51
  52  .psize Y[,X]
  53         Set the paper size to X wide and Y high. Setting a psize Y of
  54         zero will suppress form feeds except where demanded by .eject
  55
  56  If the counter goes below zero, listing is suppressed.
  57
  58  Listings are a maintained by read calling various listing_<foo>
  59  functions.  What happens most is that the macro NO_LISTING is not
  60  defined (from the Makefile), then the macro LISTING_NEWLINE expands
  61  into a call to listing_newline.  The call is done from read.c, every
  62  time it sees a newline, and -l is on the command line.
  63
  64  The function listing_newline remembers the frag associated with the
  65  newline, and creates a new frag - note that this is wasteful, but not
  66  a big deal, since listing slows things down a lot anyway.  The
  67  function also rememebers when the filename changes.
  68
  69  When all the input has finished, and gas has had a chance to settle
  70  down, the listing is output. This is done by running down the list of
  71  frag/source file records, and opening the files as needed and printing
  72  out the bytes and chars associated with them.
  73
  74  The only things which the architecture can change about the listing
  75  are defined in these macros:
  76
  77  LISTING_HEADER         The name of the architecture
  78  LISTING_WORD_SIZE      The make of the number of bytes in a word, this determines
  79                         the clumping of the output data. eg a value of
  80                         2 makes words look like 1234 5678, whilst 1
  81                         would make the same value look like 12 34 56
  82                         78
  83  LISTING_LHS_WIDTH      Number of words of above size for the lhs
  84
  85  LISTING_LHS_WIDTH_SECOND   Number of words for the data on the lhs
  86                         for the second line
  87
  88  LISTING_LHS_CONT_LINES Max number of lines to use up for a continutation
  89  LISTING_RHS_WIDTH      Number of chars from the input file to print
  90                         on a line
  91 */
  92
  93 #include <ctype.h>
  94
  95 #include "as.h"
  96 #include <obstack.h>
  97 #include "input-file.h"
  98 #include "subsegs.h"
  99
 100 #ifndef NO_LISTING
 101
 102 #ifndef LISTING_HEADER
 103 #define LISTING_HEADER "GAS LISTING"
 104 #endif
 105 #ifndef LISTING_WORD_SIZE
 106 #define LISTING_WORD_SIZE 4
 107 #endif
 108 #ifndef LISTING_LHS_WIDTH
 109 #define LISTING_LHS_WIDTH ((LISTING_WORD_SIZE) > 4 ? 1 : 4 / (LISTING_WORD_SIZE))
 110 #endif
 111 #ifndef LISTING_LHS_WIDTH_SECOND
 112 #define LISTING_LHS_WIDTH_SECOND LISTING_LHS_WIDTH
 113 #endif
 114 #ifndef LISTING_RHS_WIDTH
 115 #define LISTING_RHS_WIDTH 100
 116 #endif
 117 #ifndef LISTING_LHS_CONT_LINES
 118 #define LISTING_LHS_CONT_LINES 4
 119 #endif
 120
 121 /* This structure remembers which .s were used.  */
 122 typedef struct file_info_struct {
 123   struct file_info_struct * next;
 124   char *                    filename;
 125   long                      pos;
 126   unsigned int              linenum;
 127   int                       at_end;
 128 } file_info_type;
 129
 130 /* This structure rememebrs which line from which file goes into which
 131    frag.  */
 132 struct list_info_struct {
 133   /* Frag which this line of source is nearest to.  */
 134   fragS *frag;
 135
 136   /* The actual line in the source file.  */
 137   unsigned int line;
 138   /* Pointer to the file info struct for the file which this line
 139      belongs to.  */
 140   file_info_type *file;
 141
 142   /* The expanded text of any macro that may have been executing.  */
 143   char *line_contents;
 144
 145   /* Next in list.  */
 146   struct list_info_struct *next;
 147
 148   /* Pointer to the file info struct for the high level language
 149      source line that belongs here.  */
 150   file_info_type *hll_file;
 151   /* High level language source line.  */
 152   unsigned int hll_line;
 153
 154   /* Pointer to any error message associated with this line.  */
 155   char *message;
 156
 157   enum {
 158     EDICT_NONE,
 159     EDICT_SBTTL,
 160     EDICT_TITLE,
 161     EDICT_NOLIST,
 162     EDICT_LIST,
 163     EDICT_NOLIST_NEXT,
 164     EDICT_EJECT
 165   } edict;
 166   char *edict_arg;
 167
 168   /* Nonzero if this line is to be omitted because it contains
 169      debugging information.  This can become a flags field if we come
 170      up with more information to store here.  */
 171   int debugging;
 172 };
 173
 174 typedef struct list_info_struct list_info_type;
 175
 176 int listing_lhs_width        = LISTING_LHS_WIDTH;
 177 int listing_lhs_width_second = LISTING_LHS_WIDTH_SECOND;
 178 int listing_lhs_cont_lines   = LISTING_LHS_CONT_LINES;
 179 int listing_rhs_width        = LISTING_RHS_WIDTH;
 180
 181 struct list_info_struct *        listing_tail;
 182
 183 static file_info_type *          file_info_head;
 184 static file_info_type *          last_open_file_info;
 185 static FILE *                    last_open_file;
 186 static struct list_info_struct * head;
 187 static int                       paper_width = 200;
 188 static int                       paper_height = 60;
 189
 190 extern int                       listing;
 191
 192 /* File to output listings to.  */
 193 static FILE *list_file;
 194
 195 /* This static array is used to keep the text of data to be printed
 196    before the start of the line.  */
 197
 198 #define MAX_BYTES                                                       \
 199   (((LISTING_WORD_SIZE * 2) + 1) * listing_lhs_width                    \
 200    + ((((LISTING_WORD_SIZE * 2) + 1) * listing_lhs_width_second)        \
 201       * listing_lhs_cont_lines)                                         \
 202    + 20)
 203
 204 static char *data_buffer;
 205
 206 /* Prototypes.  */
 207 static void listing_message PARAMS ((const char *name, const char *message));
 208 static file_info_type *file_info PARAMS ((const char *file_name));
 209 static void new_frag PARAMS ((void));
 210 static char *buffer_line PARAMS ((file_info_type *file,
 211                                   char *line, unsigned int size));
 212 static void listing_page PARAMS ((list_info_type *list));
 213 static unsigned int calc_hex PARAMS ((list_info_type *list));
 214 static void print_lines PARAMS ((list_info_type *, unsigned int,
 215                                  char *, unsigned int));
 216 static void list_symbol_table PARAMS ((void));
 217 static void print_source PARAMS ((file_info_type *current_file,
 218                                   list_info_type *list,
 219                                   char *buffer,
 220                                   unsigned int width));
 221 static int debugging_pseudo PARAMS ((list_info_type *, const char *));
 222 static void listing_listing PARAMS ((char *name));
 223
 224 static void
 225 listing_message (name, message)
 226      const char *name;
 227      const char *message;
 228 {
 229   if (listing_tail != (list_info_type *) NULL)
 230     {
 231       unsigned int l = strlen (name) + strlen (message) + 1;
 232       char *n = (char *) xmalloc (l);
 233       strcpy (n, name);
 234       strcat (n, message);
 235       listing_tail->message = n;
 236     }
 237 }
 238
 239 void
 240 listing_warning (message)
 241      const char *message;
 242 {
 243   listing_message (_("Warning:"), message);
 244 }
 245
 246 void
 247 listing_error (message)
 248      const char *message;
 249 {
 250   listing_message (_("Error:"), message);
 251 }
 252
 253 static file_info_type *
 254 file_info (file_name)
 255      const char *file_name;
 256 {
 257   /* Find an entry with this file name.  */
 258   file_info_type *p = file_info_head;
 259
 260   while (p != (file_info_type *) NULL)
 261     {
 262       if (strcmp (p->filename, file_name) == 0)
 263         return p;
 264       p = p->next;
 265     }
 266
 267   /* Make new entry.  */
 268
 269   p = (file_info_type *) xmalloc (sizeof (file_info_type));
 270   p->next = file_info_head;
 271   file_info_head = p;
 272   p->filename = xmalloc ((unsigned long) strlen (file_name) + 1);
 273   strcpy (p->filename, file_name);
 274   p->pos = 0;
 275   p->linenum = 0;
 276   p->at_end = 0;
 277
 278   return p;
 279 }
 280
 281 static void
 282 new_frag ()
 283 {
 284
 285   frag_wane (frag_now);
 286   frag_new (0);
 287
 288 }
 289
 290 void
 291 listing_newline (ps)
 292      char *ps;
 293 {
 294   char *file;
 295   unsigned int line;
 296   static unsigned int last_line = 0xffff;
 297   static char *last_file = NULL;
 298   list_info_type *new = NULL;
 299
 300   if (listing == 0)
 301     return;
 302
 303   if (now_seg == absolute_section)
 304     return;
 305
 306 #ifdef OBJ_ELF
 307   /* In ELF, anything in a section beginning with .debug or .line is
 308      considered to be debugging information.  This includes the
 309      statement which switches us into the debugging section, which we
 310      can only set after we are already in the debugging section.  */
 311   if ((listing & LISTING_NODEBUG) != 0
 312       && listing_tail != NULL
 313       && ! listing_tail->debugging)
 314     {
 315       const char *segname;
 316
 317       segname = segment_name (now_seg);
 318       if (strncmp (segname, ".debug", sizeof ".debug" - 1) == 0
 319           || strncmp (segname, ".line", sizeof ".line" - 1) == 0)
 320         listing_tail->debugging = 1;
 321     }
 322 #endif
 323
 324   as_where (&file, &line);
 325   if (ps == NULL)
 326     {
 327       if (line == last_line
 328           && !(last_file && file && strcmp (file, last_file)))
 329         return;
 330
 331       new = (list_info_type *) xmalloc (sizeof (list_info_type));
 332
 333       /* Detect if we are reading from stdin by examining the file
 334          name returned by as_where().
 335
 336          [FIXME: We rely upon the name in the strcmp below being the
 337          same as the one used by input_scrub_new_file(), if that is
 338          not true, then this code will fail].
 339
 340          If we are reading from stdin, then we need to save each input
 341          line here (assuming of course that we actually have a line of
 342          input to read), so that it can be displayed in the listing
 343          that is produced at the end of the assembly.  */
 344       if (strcmp (file, _("{standard input}")) == 0
 345           && input_line_pointer != NULL)
 346         {
 347           char *copy;
 348           int len;
 349           int seen_quote = 0;
 350
 351           for (copy = input_line_pointer - 1;
 352                *copy && (seen_quote
 353                          || (! is_end_of_line [(unsigned char) *copy]));
 354                copy++)
 355             if (*copy == '"' && copy[-1] != '\\')
 356               seen_quote = ! seen_quote;
 357
 358           len = (copy - input_line_pointer) + 2;
 359
 360           copy = xmalloc (len);
 361
 362           if (copy != NULL)
 363             {
 364               char *src = input_line_pointer - 1;
 365               char *dest = copy;
 366
 367               while (--len)
 368                 {
 369                   unsigned char c = *src++;
 370
 371                   /* Omit control characters in the listing.  */
 372                   if (isascii (c) && ! iscntrl (c))
 373                     *dest++ = c;
 374                 }
 375
 376               *dest = 0;
 377             }
 378
 379           new->line_contents = copy;
 380         }
 381       else
 382         new->line_contents = NULL;
 383     }
 384   else
 385     {
 386       new = (list_info_type *) xmalloc (sizeof (list_info_type));
 387       new->line_contents = ps;
 388     }
 389
 390   last_line = line;
 391   last_file = file;
 392
 393   new_frag ();
 394
 395   if (listing_tail)
 396     listing_tail->next = new;
 397   else
 398     head = new;
 399
 400   listing_tail = new;
 401
 402   new->frag = frag_now;
 403   new->line = line;
 404   new->file = file_info (file);
 405   new->next = (list_info_type *) NULL;
 406   new->message = (char *) NULL;
 407   new->edict = EDICT_NONE;
 408   new->hll_file = (file_info_type *) NULL;
 409   new->hll_line = 0;
 410   new->debugging = 0;
 411
 412   new_frag ();
 413
 414 #ifdef OBJ_ELF
 415   /* In ELF, anything in a section beginning with .debug or .line is
 416      considered to be debugging information.  */
 417   if ((listing & LISTING_NODEBUG) != 0)
 418     {
 419       const char *segname;
 420
 421       segname = segment_name (now_seg);
 422       if (strncmp (segname, ".debug", sizeof ".debug" - 1) == 0
 423           || strncmp (segname, ".line", sizeof ".line" - 1) == 0)
 424         new->debugging = 1;
 425     }
 426 #endif
 427 }
 428
 429 /* Attach all current frags to the previous line instead of the
 430    current line.  This is called by the MIPS backend when it discovers
 431    that it needs to add some NOP instructions; the added NOP
 432    instructions should go with the instruction that has the delay, not
 433    with the new instruction.  */
 434
 435 void
 436 listing_prev_line ()
 437 {
 438   list_info_type *l;
 439   fragS *f;
 440
 441   if (head == (list_info_type *) NULL
 442       || head == listing_tail)
 443     return;
 444
 445   new_frag ();
 446
 447   for (l = head; l->next != listing_tail; l = l->next)
 448     ;
 449
 450   for (f = frchain_now->frch_root; f != (fragS *) NULL; f = f->fr_next)
 451     if (f->line == listing_tail)
 452       f->line = l;
 453
 454   listing_tail->frag = frag_now;
 455   new_frag ();
 456 }
 457
 458 /* This function returns the next source line from the file supplied,
 459    truncated to size.  It appends a fake line to the end of each input
 460    file to make.  */
 461
 462 static char *
 463 buffer_line (file, line, size)
 464      file_info_type *file;
 465      char *line;
 466      unsigned int size;
 467 {
 468   unsigned int count = 0;
 469   int c;
 470
 471   char *p = line;
 472
 473   /* If we couldn't open the file, return an empty line.  */
 474   if (file->at_end)
 475     return "";
 476
 477   /* Check the cache and see if we last used this file.  */
 478   if (!last_open_file_info || file != last_open_file_info)
 479     {
 480       if (last_open_file)
 481         {
 482           last_open_file_info->pos = ftell (last_open_file);
 483           fclose (last_open_file);
 484         }
 485
 486       last_open_file_info = file;
 487       last_open_file = fopen (file->filename, "r");
 488       if (last_open_file == NULL)
 489         {
 490           file->at_end = 1;
 491           return "";
 492         }
 493
 494       /* Seek to where we were last time this file was open.  */
 495       if (file->pos)
 496         fseek (last_open_file, file->pos, SEEK_SET);
 497     }
 498
 499   c = fgetc (last_open_file);
 500
 501   /* Leave room for null.  */
 502   size -= 1;
 503
 504   while (c != EOF && c != '\n')
 505     {
 506       if (count < size)
 507         *p++ = c;
 508       count++;
 509
 510       c = fgetc (last_open_file);
 511
 512     }
 513   if (c == EOF)
 514     {
 515       file->at_end = 1;
 516       *p++ = '.';
 517       *p++ = '.';
 518       *p++ = '.';
 519     }
 520   file->linenum++;
 521   *p++ = 0;
 522   return line;
 523 }
 524
 525 static const char *fn;
 526
 527 static unsigned int eject;      /* Eject pending */
 528 static unsigned int page;       /* Current page number */
 529 static char *title;             /* Current title */
 530 static char *subtitle;          /* Current subtitle */
 531 static unsigned int on_page;    /* Number of lines printed on current page */
 532
 533 static void
 534 listing_page (list)
 535      list_info_type *list;
 536 {
 537   /* Grope around, see if we can see a title or subtitle edict coming up
 538      soon.  (we look down 10 lines of the page and see if it's there)  */
 539   if ((eject || (on_page >= (unsigned int) paper_height))
 540       && paper_height != 0)
 541     {
 542       unsigned int c = 10;
 543       int had_title = 0;
 544       int had_subtitle = 0;
 545
 546       page++;
 547
 548       while (c != 0 && list)
 549         {
 550           if (list->edict == EDICT_SBTTL && !had_subtitle)
 551             {
 552               had_subtitle = 1;
 553               subtitle = list->edict_arg;
 554             }
 555           if (list->edict == EDICT_TITLE && !had_title)
 556             {
 557               had_title = 1;
 558               title = list->edict_arg;
 559             }
 560           list = list->next;
 561           c--;
 562         }
 563
 564       if (page > 1)
 565         {
 566           fprintf (list_file, "\f");
 567         }
 568
 569       fprintf (list_file, "%s %s \t\t\tpage %d\n", LISTING_HEADER, fn, page);
 570       fprintf (list_file, "%s\n", title);
 571       fprintf (list_file, "%s\n", subtitle);
 572       on_page = 3;
 573       eject = 0;
 574     }
 575 }
 576
 577 static unsigned int
 578 calc_hex (list)
 579      list_info_type *list;
 580 {
 581   int data_buffer_size;
 582   list_info_type *first = list;
 583   unsigned int address = ~(unsigned int) 0;
 584   fragS *frag;
 585   fragS *frag_ptr;
 586   unsigned int octet_in_frag;
 587
 588   /* Find first frag which says it belongs to this line.  */
 589   frag = list->frag;
 590   while (frag && frag->line != list)
 591     frag = frag->fr_next;
 592
 593   frag_ptr = frag;
 594
 595   data_buffer_size = 0;
 596
 597   /* Dump all the frags which belong to this line.  */
 598   while (frag_ptr != (fragS *) NULL && frag_ptr->line == first)
 599     {
 600       /* Print as many bytes from the fixed part as is sensible.  */
 601       octet_in_frag = 0;
 602       while ((offsetT) octet_in_frag < frag_ptr->fr_fix
 603              && data_buffer_size < MAX_BYTES - 3)
 604         {
 605           if (address == ~(unsigned int) 0)
 606             {
 607               address = frag_ptr->fr_address / OCTETS_PER_BYTE;
 608             }
 609
 610           sprintf (data_buffer + data_buffer_size,
 611                    "%02X",
 612                    (frag_ptr->fr_literal[octet_in_frag]) & 0xff);
 613           data_buffer_size += 2;
 614           octet_in_frag++;
 615         }
 616     if (frag_ptr->fr_type == rs_fill)
 617       {
 618         unsigned int var_rep_max = octet_in_frag;
 619         unsigned int var_rep_idx = octet_in_frag;
 620
 621         /* Print as many bytes from the variable part as is sensible.  */
 622         while (((offsetT) octet_in_frag
 623                 < (frag_ptr->fr_fix + frag_ptr->fr_var * frag_ptr->fr_offset))
 624                && data_buffer_size < MAX_BYTES - 3)
 625           {
 626             if (address == ~(unsigned int) 0)
 627               {
 628                 address = frag_ptr->fr_address / OCTETS_PER_BYTE;
 629               }
 630             sprintf (data_buffer + data_buffer_size,
 631                      "%02X",
 632                      (frag_ptr->fr_literal[var_rep_idx]) & 0xff);
 633 #if 0
 634             data_buffer[data_buffer_size++] = '*';
 635             data_buffer[data_buffer_size++] = '*';
 636 #endif
 637             data_buffer_size += 2;
 638
 639             var_rep_idx++;
 640             octet_in_frag++;
 641
 642             if ((offsetT) var_rep_idx >= frag_ptr->fr_fix + frag_ptr->fr_var)
 643               var_rep_idx = var_rep_max;
 644           }
 645       }
 646
 647       frag_ptr = frag_ptr->fr_next;
 648     }
 649   data_buffer[data_buffer_size] = '\0';
 650   return address;
 651 }
 652
 653 static void
 654 print_lines (list, lineno, string, address)
 655      list_info_type *list;
 656      unsigned int lineno;
 657      char *string;
 658      unsigned int address;
 659 {
 660   unsigned int idx;
 661   unsigned int nchars;
 662   unsigned int lines;
 663   unsigned int octet_in_word = 0;
 664   char *src = data_buffer;
 665   int cur;
 666
 667   /* Print the stuff on the first line.  */
 668   listing_page (list);
 669   nchars = (LISTING_WORD_SIZE * 2 + 1) * listing_lhs_width;
 670
 671   /* Print the hex for the first line.  */
 672   if (address == ~(unsigned int) 0)
 673     {
 674       fprintf (list_file, "% 4d     ", lineno);
 675       for (idx = 0; idx < nchars; idx++)
 676         fprintf (list_file, " ");
 677
 678       fprintf (list_file, "\t%s\n", string ? string : "");
 679
 680       on_page++;
 681
 682       listing_page (0);
 683
 684       return;
 685     }
 686
 687   if (had_errors ())
 688     fprintf (list_file, "% 4d ???? ", lineno);
 689   else
 690     fprintf (list_file, "% 4d %04x ", lineno, address);
 691
 692   /* And the data to go along with it.  */
 693   idx = 0;
 694   cur = 0;
 695   while (src[cur] && idx < nchars)
 696     {
 697       int offset;
 698       offset = cur;
 699       fprintf (list_file, "%c%c", src[offset], src[offset + 1]);
 700       cur += 2;
 701       octet_in_word++;
 702
 703       if (octet_in_word == LISTING_WORD_SIZE)
 704         {
 705           fprintf (list_file, " ");
 706           idx++;
 707           octet_in_word = 0;
 708         }
 709
 710       idx += 2;
 711     }
 712
 713   for (; idx < nchars; idx++)
 714     fprintf (list_file, " ");
 715
 716   fprintf (list_file, "\t%s\n", string ? string : "");
 717   on_page++;
 718   listing_page (list);
 719
 720   if (list->message)
 721     {
 722       fprintf (list_file, "****  %s\n", list->message);
 723       listing_page (list);
 724       on_page++;
 725     }
 726
 727   for (lines = 0;
 728        lines < (unsigned int) listing_lhs_cont_lines
 729          && src[cur];
 730        lines++)
 731     {
 732       nchars = ((LISTING_WORD_SIZE * 2) + 1) * listing_lhs_width_second - 1;
 733       idx = 0;
 734
 735       /* Print any more lines of data, but more compactly.  */
 736       fprintf (list_file, "% 4d      ", lineno);
 737
 738       while (src[cur] && idx < nchars)
 739         {
 740           int offset;
 741           offset = cur;
 742           fprintf (list_file, "%c%c", src[offset], src[offset + 1]);
 743           cur += 2;
 744           idx += 2;
 745           octet_in_word++;
 746
 747           if (octet_in_word == LISTING_WORD_SIZE)
 748             {
 749               fprintf (list_file, " ");
 750               idx++;
 751               octet_in_word = 0;
 752             }
 753         }
 754
 755       fprintf (list_file, "\n");
 756       on_page++;
 757       listing_page (list);
 758     }
 759 }
 760
 761 static void
 762 list_symbol_table ()
 763 {
 764   extern symbolS *symbol_rootP;
 765   int got_some = 0;
 766
 767   symbolS *ptr;
 768   eject = 1;
 769   listing_page (0);
 770
 771   for (ptr = symbol_rootP; ptr != (symbolS *) NULL; ptr = symbol_next (ptr))
 772     {
 773       if (SEG_NORMAL (S_GET_SEGMENT (ptr))
 774           || S_GET_SEGMENT (ptr) == absolute_section)
 775         {
 776 #ifdef BFD_ASSEMBLER
 777           /* Don't report section symbols.  They are not interesting.  */
 778           if (symbol_section_p (ptr))
 779             continue;
 780 #endif
 781           if (S_GET_NAME (ptr))
 782             {
 783               char buf[30], fmt[8];
 784               valueT val = S_GET_VALUE (ptr);
 785
 786               /* @@ Note that this is dependent on the compilation options,
 787                  not solely on the target characteristics.  */
 788               if (sizeof (val) == 4 && sizeof (int) == 4)
 789                 sprintf (buf, "%08lx", (unsigned long) val);
 790               else if (sizeof (val) <= sizeof (unsigned long))
 791                 {
 792                   sprintf (fmt, "%%0%lulx",
 793                            (unsigned long) (sizeof (val) * 2));
 794                   sprintf (buf, fmt, (unsigned long) val);
 795                 }
 796 #if defined (BFD64)
 797               else if (sizeof (val) > 4)
 798                 sprintf_vma (buf, val);
 799 #endif
 800               else
 801                 abort ();
 802
 803               if (!got_some)
 804                 {
 805                   fprintf (list_file, "DEFINED SYMBOLS\n");
 806                   on_page++;
 807                   got_some = 1;
 808                 }
 809
 810               if (symbol_get_frag (ptr) && symbol_get_frag (ptr)->line)
 811                 {
 812                   fprintf (list_file, "%20s:%-5d  %s:%s %s\n",
 813                            symbol_get_frag (ptr)->line->file->filename,
 814                            symbol_get_frag (ptr)->line->line,
 815                            segment_name (S_GET_SEGMENT (ptr)),
 816                            buf, S_GET_NAME (ptr));
 817                 }
 818               else
 819                 {
 820                   fprintf (list_file, "%33s:%s %s\n",
 821                            segment_name (S_GET_SEGMENT (ptr)),
 822                            buf, S_GET_NAME (ptr));
 823                 }
 824
 825               on_page++;
 826               listing_page (0);
 827             }
 828         }
 829
 830     }
 831   if (!got_some)
 832     {
 833       fprintf (list_file, "NO DEFINED SYMBOLS\n");
 834       on_page++;
 835     }
 836   fprintf (list_file, "\n");
 837   on_page++;
 838   listing_page (0);
 839
 840   got_some = 0;
 841
 842   for (ptr = symbol_rootP; ptr != (symbolS *) NULL; ptr = symbol_next (ptr))
 843     {
 844       if (S_GET_NAME (ptr) && strlen (S_GET_NAME (ptr)) != 0)
 845         {
 846           if (S_GET_SEGMENT (ptr) == undefined_section)
 847             {
 848               if (!got_some)
 849                 {
 850                   got_some = 1;
 851                   fprintf (list_file, "UNDEFINED SYMBOLS\n");
 852                   on_page++;
 853                   listing_page (0);
 854                 }
 855               fprintf (list_file, "%s\n", S_GET_NAME (ptr));
 856               on_page++;
 857               listing_page (0);
 858             }
 859         }
 860     }
 861   if (!got_some)
 862     {
 863       fprintf (list_file, "NO UNDEFINED SYMBOLS\n");
 864       on_page++;
 865       listing_page (0);
 866     }
 867 }
 868
 869 static void
 870 print_source (current_file, list, buffer, width)
 871      file_info_type *current_file;
 872      list_info_type *list;
 873      char *buffer;
 874      unsigned int width;
 875 {
 876   if (!current_file->at_end)
 877     {
 878       while (current_file->linenum < list->hll_line
 879              && !current_file->at_end)
 880         {
 881           char *p = buffer_line (current_file, buffer, width);
 882           fprintf (list_file, "%4u:%-13s **** %s\n", current_file->linenum,
 883                    current_file->filename, p);
 884           on_page++;
 885           listing_page (list);
 886         }
 887     }
 888 }
 889
 890 /* Sometimes the user doesn't want to be bothered by the debugging
 891    records inserted by the compiler, see if the line is suspicious.  */
 892
 893 static int
 894 debugging_pseudo (list, line)
 895      list_info_type *list;
 896      const char *line;
 897 {
 898   static int in_debug;
 899   int was_debug;
 900
 901   if (list->debugging)
 902     {
 903       in_debug = 1;
 904       return 1;
 905     }
 906
 907   was_debug = in_debug;
 908   in_debug = 0;
 909
 910   while (isspace ((unsigned char) *line))
 911     line++;
 912
 913   if (*line != '.')
 914     {
 915 #ifdef OBJ_ELF
 916       /* The ELF compiler sometimes emits blank lines after switching
 917          out of a debugging section.  If the next line drops us back
 918          into debugging information, then don't print the blank line.
 919          This is a hack for a particular compiler behaviour, not a
 920          general case.  */
 921       if (was_debug
 922           && *line == '\0'
 923           && list->next != NULL
 924           && list->next->debugging)
 925         {
 926           in_debug = 1;
 927           return 1;
 928         }
 929 #endif
 930
 931       return 0;
 932     }
 933
 934   line++;
 935
 936   if (strncmp (line, "def", 3) == 0)
 937     return 1;
 938   if (strncmp (line, "val", 3) == 0)
 939     return 1;
 940   if (strncmp (line, "scl", 3) == 0)
 941     return 1;
 942   if (strncmp (line, "line", 4) == 0)
 943     return 1;
 944   if (strncmp (line, "endef", 5) == 0)
 945     return 1;
 946   if (strncmp (line, "ln", 2) == 0)
 947     return 1;
 948   if (strncmp (line, "type", 4) == 0)
 949     return 1;
 950   if (strncmp (line, "size", 4) == 0)
 951     return 1;
 952   if (strncmp (line, "dim", 3) == 0)
 953     return 1;
 954   if (strncmp (line, "tag", 3) == 0)
 955     return 1;
 956
 957   if (strncmp (line, "stabs", 5) == 0)
 958     return 1;
 959   if (strncmp (line, "stabn", 5) == 0)
 960     return 1;
 961
 962   return 0;
 963 }
 964
 965 static void
 966 listing_listing (name)
 967      char *name ATTRIBUTE_UNUSED;
 968 {
 969   list_info_type *list = head;
 970   file_info_type *current_hll_file = (file_info_type *) NULL;
 971   char *message;
 972   char *buffer;
 973   char *p;
 974   int show_listing = 1;
 975   unsigned int width;
 976
 977   buffer = xmalloc (listing_rhs_width);
 978   data_buffer = xmalloc (MAX_BYTES);
 979   eject = 1;
 980   list = head;
 981
 982   while (list != (list_info_type *) NULL && 0)
 983     {
 984       if (list->next)
 985         list->frag = list->next->frag;
 986       list = list->next;
 987
 988     }
 989
 990   list = head->next;
 991
 992   while (list)
 993     {
 994       unsigned int list_line;
 995
 996       width = listing_rhs_width > paper_width ? paper_width :
 997         listing_rhs_width;
 998
 999       list_line = list->line;
1000       switch (list->edict)
1001         {
1002         case EDICT_LIST:
1003           /* Skip all lines up to the current.  */
1004           list_line--;
1005           break;
1006         case EDICT_NOLIST:
1007           show_listing--;
1008           break;
1009         case EDICT_NOLIST_NEXT:
1010           break;
1011         case EDICT_EJECT:
1012           break;
1013         case EDICT_NONE:
1014           break;
1015         case EDICT_TITLE:
1016           title = list->edict_arg;
1017           break;
1018         case EDICT_SBTTL:
1019           subtitle = list->edict_arg;
1020           break;
1021         default:
1022           abort ();
1023         }
1024
1025       if (show_listing <= 0)
1026         {
1027           while (list->file->linenum < list_line
1028                  && !list->file->at_end)
1029             p = buffer_line (list->file, buffer, width);
1030         }
1031
1032       if (list->edict == EDICT_LIST)
1033         {
1034           /* Enable listing for the single line that caused the enable.  */
1035           list_line++;
1036           show_listing++;
1037         }
1038
1039       if (show_listing > 0)
1040         {
1041           /* Scan down the list and print all the stuff which can be done
1042              with this line (or lines).  */
1043           message = 0;
1044
1045           if (list->hll_file)
1046             {
1047               current_hll_file = list->hll_file;
1048             }
1049
1050           if (current_hll_file && list->hll_line && (listing & LISTING_HLL))
1051             {
1052               print_source (current_hll_file, list, buffer, width);
1053             }
1054
1055           if (list->line_contents)
1056             {
1057               if (!((listing & LISTING_NODEBUG)
1058                     && debugging_pseudo (list, list->line_contents)))
1059                 {
1060                   print_lines (list,
1061                                list->file->linenum == 0 ? list->line : list->file->linenum,
1062                                list->line_contents, calc_hex (list));
1063                 }
1064               free (list->line_contents);
1065               list->line_contents = NULL;
1066             }
1067           else
1068             {
1069               while (list->file->linenum < list_line
1070                      && !list->file->at_end)
1071                 {
1072                   unsigned int address;
1073
1074                   p = buffer_line (list->file, buffer, width);
1075
1076                   if (list->file->linenum < list_line)
1077                     address = ~(unsigned int) 0;
1078                   else
1079                     address = calc_hex (list);
1080
1081                   if (!((listing & LISTING_NODEBUG)
1082                         && debugging_pseudo (list, p)))
1083                     print_lines (list, list->file->linenum, p, address);
1084                 }
1085             }
1086
1087           if (list->edict == EDICT_EJECT)
1088             {
1089               eject = 1;
1090             }
1091         }
1092
1093       if (list->edict == EDICT_NOLIST_NEXT)
1094         --show_listing;
1095
1096       list = list->next;
1097     }
1098
1099   free (buffer);
1100   free (data_buffer);
1101   data_buffer = NULL;
1102 }
1103
1104 void
1105 listing_print (name)
1106      char *name;
1107 {
1108   int using_stdout;
1109
1110   title = "";
1111   subtitle = "";
1112
1113   if (name == NULL)
1114     {
1115       list_file = stdout;
1116       using_stdout = 1;
1117     }
1118   else
1119     {
1120       list_file = fopen (name, "w");
1121       if (list_file != NULL)
1122         using_stdout = 0;
1123       else
1124         {
1125           as_perror (_("can't open list file: %s"), name);
1126           list_file = stdout;
1127           using_stdout = 1;
1128         }
1129     }
1130
1131   if (listing & LISTING_NOFORM)
1132     {
1133       paper_height = 0;
1134     }
1135
1136   if (listing & LISTING_LISTING)
1137     {
1138       listing_listing (name);
1139     }
1140
1141   if (listing & LISTING_SYMBOLS)
1142     {
1143       list_symbol_table ();
1144     }
1145
1146   if (! using_stdout)
1147     {
1148       if (fclose (list_file) == EOF)
1149         as_perror (_("error closing list file: %s"), name);
1150     }
1151
1152   if (last_open_file)
1153     {
1154       fclose (last_open_file);
1155     }
1156 }
1157
1158 void
1159 listing_file (name)
1160      const char *name;
1161 {
1162   fn = name;
1163 }
1164
1165 void
1166 listing_eject (ignore)
1167      int ignore ATTRIBUTE_UNUSED;
1168 {
1169   if (listing)
1170     listing_tail->edict = EDICT_EJECT;
1171 }
1172
1173 void
1174 listing_flags (ignore)
1175      int ignore ATTRIBUTE_UNUSED;
1176 {
1177   while ((*input_line_pointer++) && (*input_line_pointer != '\n'))
1178     input_line_pointer++;
1179
1180 }
1181
1182 /* Turn listing on or off.  An argument of 0 means to turn off
1183    listing.  An argument of 1 means to turn on listing.  An argument
1184    of 2 means to turn off listing, but as of the next line; that is,
1185    the current line should be listed, but the next line should not.  */
1186
1187 void
1188 listing_list (on)
1189      int on;
1190 {
1191   if (listing)
1192     {
1193       switch (on)
1194         {
1195         case 0:
1196           if (listing_tail->edict == EDICT_LIST)
1197             listing_tail->edict = EDICT_NONE;
1198           else
1199             listing_tail->edict = EDICT_NOLIST;
1200           break;
1201         case 1:
1202           if (listing_tail->edict == EDICT_NOLIST
1203               || listing_tail->edict == EDICT_NOLIST_NEXT)
1204             listing_tail->edict = EDICT_NONE;
1205           else
1206             listing_tail->edict = EDICT_LIST;
1207           break;
1208         case 2:
1209           listing_tail->edict = EDICT_NOLIST_NEXT;
1210           break;
1211         default:
1212           abort ();
1213         }
1214     }
1215 }
1216
1217 void
1218 listing_psize (width_only)
1219      int width_only;
1220 {
1221   if (! width_only)
1222     {
1223       paper_height = get_absolute_expression ();
1224
1225       if (paper_height < 0 || paper_height > 1000)
1226         {
1227           paper_height = 0;
1228           as_warn (_("strange paper height, set to no form"));
1229         }
1230
1231       if (*input_line_pointer != ',')
1232         {
1233           demand_empty_rest_of_line ();
1234           return;
1235         }
1236
1237       ++input_line_pointer;
1238     }
1239
1240   paper_width = get_absolute_expression ();
1241
1242   demand_empty_rest_of_line ();
1243 }
1244
1245 void
1246 listing_nopage (ignore)
1247      int ignore ATTRIBUTE_UNUSED;
1248 {
1249   paper_height = 0;
1250 }
1251
1252 void
1253 listing_title (depth)
1254      int depth;
1255 {
1256   int quoted;
1257   char *start;
1258   char *ttl;
1259   unsigned int length;
1260
1261   SKIP_WHITESPACE ();
1262   if (*input_line_pointer != '\"')
1263     quoted = 0;
1264   else
1265     {
1266       quoted = 1;
1267       ++input_line_pointer;
1268     }
1269
1270   start = input_line_pointer;
1271
1272   while (*input_line_pointer)
1273     {
1274       if (quoted
1275           ? *input_line_pointer == '\"'
1276           : is_end_of_line[(unsigned char) *input_line_pointer])
1277         {
1278           if (listing)
1279             {
1280               length = input_line_pointer - start;
1281               ttl = xmalloc (length + 1);
1282               memcpy (ttl, start, length);
1283               ttl[length] = 0;
1284               listing_tail->edict = depth ? EDICT_SBTTL : EDICT_TITLE;
1285               listing_tail->edict_arg = ttl;
1286             }
1287           if (quoted)
1288             input_line_pointer++;
1289           demand_empty_rest_of_line ();
1290           return;
1291         }
1292       else if (*input_line_pointer == '\n')
1293         {
1294           as_bad (_("New line in title"));
1295           demand_empty_rest_of_line ();
1296           return;
1297         }
1298       else
1299         {
1300           input_line_pointer++;
1301         }
1302     }
1303 }
1304
1305 void
1306 listing_source_line (line)
1307      unsigned int line;
1308 {
1309   if (listing)
1310     {
1311       new_frag ();
1312       listing_tail->hll_line = line;
1313       new_frag ();
1314     }
1315 }
1316
1317 void
1318 listing_source_file (file)
1319      const char *file;
1320 {
1321   if (listing)
1322     listing_tail->hll_file = file_info (file);
1323 }
1324
1325 #else
1326
1327 /* Dummy functions for when compiled without listing enabled.  */
1328
1329 void
1330 listing_flags (ignore)
1331      int ignore;
1332 {
1333   s_ignore (0);
1334 }
1335
1336 void
1337 listing_list (on)
1338      int on;
1339 {
1340   s_ignore (0);
1341 }
1342
1343 void
1344 listing_eject (ignore)
1345      int ignore;
1346 {
1347   s_ignore (0);
1348 }
1349
1350 void
1351 listing_psize (ignore)
1352      int ignore;
1353 {
1354   s_ignore (0);
1355 }
1356
1357 void
1358 listing_nopage (ignore)
1359      int ignore;
1360 {
1361   s_ignore (0);
1362 }
1363
1364 void
1365 listing_title (depth)
1366      int depth;
1367 {
1368   s_ignore (0);
1369 }
1370
1371 void
1372 listing_file (name)
1373      const char *name;
1374 {
1375
1376 }
1377
1378 void
1379 listing_newline (name)
1380      char *name;
1381 {
1382
1383 }
1384
1385 void
1386 listing_source_line (n)
1387      unsigned int n;
1388 {
1389
1390 }
1391
1392 void
1393 listing_source_file (n)
1394      const char *n;
1395 {
1396
1397 }
1398
1399 #endif