2009-07-02 Tristan Gingold <gingold@adacore.com>
[binutils.git] / gas / listing.c
blobe307be21c9a3b77c9533d1af95eedbb91156fa68
1 /* listing.c - maintain assembly listings
2 Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2005, 2006, 2007, 2008
4 Free Software Foundation, Inc.
6 This file is part of GAS, the GNU Assembler.
8 GAS is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
11 any later version.
13 GAS is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GAS; see the file COPYING. If not, write to the Free
20 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
21 02110-1301, USA. */
23 /* Contributed by Steve Chamberlain <sac@cygnus.com>
25 A listing page looks like:
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
35 If not overridden, the listing commands are:
37 .title "stuff"
38 Put "stuff" onto the title line
39 .sbttl "stuff"
40 Put stuff onto the subtitle line
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
45 .eject
46 Thow a page
47 .list
48 Increment the enable listing counter
49 .nolist
50 Decrement the enable listing counter
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
56 If the counter goes below zero, listing is suppressed.
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.
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 remembers when the filename changes.
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.
74 The only things which the architecture can change about the listing
75 are defined in these macros:
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
83 LISTING_LHS_WIDTH Number of words of above size for the lhs
85 LISTING_LHS_WIDTH_SECOND Number of words for the data on the lhs
86 for the second line
88 LISTING_LHS_CONT_LINES Max number of lines to use up for a continuation
89 LISTING_RHS_WIDTH Number of chars from the input file to print
90 on a line. */
92 #include "as.h"
93 #include "obstack.h"
94 #include "safe-ctype.h"
95 #include "input-file.h"
96 #include "subsegs.h"
97 #include "bfdver.h"
98 #include <time.h>
100 #ifndef NO_LISTING
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 #define MAX_DATELEN 30
122 /* This structure remembers which .s were used. */
123 typedef struct file_info_struct
125 struct file_info_struct * next;
126 char * filename;
127 long pos;
128 unsigned int linenum;
129 int at_end;
130 } file_info_type;
132 /* This structure remembers which line from which file goes into which
133 frag. */
134 struct list_info_struct
136 /* Frag which this line of source is nearest to. */
137 fragS *frag;
139 /* The actual line in the source file. */
140 unsigned int line;
142 /* Pointer to the file info struct for the file which this line
143 belongs to. */
144 file_info_type *file;
146 /* The expanded text of any macro that may have been executing. */
147 char *line_contents;
149 /* Next in list. */
150 struct list_info_struct *next;
152 /* Pointer to the file info struct for the high level language
153 source line that belongs here. */
154 file_info_type *hll_file;
156 /* High level language source line. */
157 unsigned int hll_line;
159 /* Pointer to any error message associated with this line. */
160 char *message;
162 enum
164 EDICT_NONE,
165 EDICT_SBTTL,
166 EDICT_TITLE,
167 EDICT_NOLIST,
168 EDICT_LIST,
169 EDICT_NOLIST_NEXT,
170 EDICT_EJECT
171 } edict;
172 char *edict_arg;
174 /* Nonzero if this line is to be omitted because it contains
175 debugging information. This can become a flags field if we come
176 up with more information to store here. */
177 int debugging;
180 typedef struct list_info_struct list_info_type;
182 int listing_lhs_width = LISTING_LHS_WIDTH;
183 int listing_lhs_width_second = LISTING_LHS_WIDTH_SECOND;
184 int listing_lhs_cont_lines = LISTING_LHS_CONT_LINES;
185 int listing_rhs_width = LISTING_RHS_WIDTH;
187 struct list_info_struct * listing_tail;
189 static file_info_type * file_info_head;
190 static file_info_type * last_open_file_info;
191 static FILE * last_open_file;
192 static struct list_info_struct * head;
193 static int paper_width = 200;
194 static int paper_height = 60;
196 extern int listing;
198 /* File to output listings to. */
199 static FILE *list_file;
201 /* This static array is used to keep the text of data to be printed
202 before the start of the line. */
204 #define MAX_BYTES \
205 (((LISTING_WORD_SIZE * 2) + 1) * listing_lhs_width \
206 + ((((LISTING_WORD_SIZE * 2) + 1) * listing_lhs_width_second) \
207 * listing_lhs_cont_lines) \
208 + 20)
210 static char *data_buffer;
212 /* Prototypes. */
213 static void listing_message (const char *, const char *);
214 static file_info_type *file_info (const char *);
215 static void new_frag (void);
216 static char *buffer_line (file_info_type *, char *, unsigned int);
217 static void listing_page (list_info_type *);
218 static unsigned int calc_hex (list_info_type *);
219 static void print_lines (list_info_type *, unsigned int, char *, unsigned int);
220 static void list_symbol_table (void);
221 static void print_source (file_info_type *, list_info_type *, char *, unsigned int);
222 static int debugging_pseudo (list_info_type *, const char *);
223 static void listing_listing (char *);
225 static void
226 listing_message (const char *name, const char *message)
228 if (listing_tail != (list_info_type *) NULL)
230 unsigned int l = strlen (name) + strlen (message) + 1;
231 char *n = (char *) xmalloc (l);
232 strcpy (n, name);
233 strcat (n, message);
234 listing_tail->message = n;
238 void
239 listing_warning (const char *message)
241 listing_message (_("Warning:"), message);
244 void
245 listing_error (const char *message)
247 listing_message (_("Error:"), message);
250 static file_info_type *
251 file_info (const char *file_name)
253 /* Find an entry with this file name. */
254 file_info_type *p = file_info_head;
256 while (p != (file_info_type *) NULL)
258 if (strcmp (p->filename, file_name) == 0)
259 return p;
260 p = p->next;
263 /* Make new entry. */
264 p = xmalloc (sizeof (file_info_type));
265 p->next = file_info_head;
266 file_info_head = p;
267 p->filename = xstrdup (file_name);
268 p->pos = 0;
269 p->linenum = 0;
270 p->at_end = 0;
272 return p;
275 static void
276 new_frag (void)
278 frag_wane (frag_now);
279 frag_new (0);
282 void
283 listing_newline (char *ps)
285 char *file;
286 unsigned int line;
287 static unsigned int last_line = 0xffff;
288 static char *last_file = NULL;
289 list_info_type *new = NULL;
291 if (listing == 0)
292 return;
294 if (now_seg == absolute_section)
295 return;
297 #ifdef OBJ_ELF
298 /* In ELF, anything in a section beginning with .debug or .line is
299 considered to be debugging information. This includes the
300 statement which switches us into the debugging section, which we
301 can only set after we are already in the debugging section. */
302 if ((listing & LISTING_NODEBUG) != 0
303 && listing_tail != NULL
304 && ! listing_tail->debugging)
306 const char *segname;
308 segname = segment_name (now_seg);
309 if (strncmp (segname, ".debug", sizeof ".debug" - 1) == 0
310 || strncmp (segname, ".line", sizeof ".line" - 1) == 0)
311 listing_tail->debugging = 1;
313 #endif
315 as_where (&file, &line);
316 if (ps == NULL)
318 if (line == last_line
319 && !(last_file && file && strcmp (file, last_file)))
320 return;
322 new = (list_info_type *) xmalloc (sizeof (list_info_type));
324 /* Detect if we are reading from stdin by examining the file
325 name returned by as_where().
327 [FIXME: We rely upon the name in the strcmp below being the
328 same as the one used by input_scrub_new_file(), if that is
329 not true, then this code will fail].
331 If we are reading from stdin, then we need to save each input
332 line here (assuming of course that we actually have a line of
333 input to read), so that it can be displayed in the listing
334 that is produced at the end of the assembly. */
335 if (strcmp (file, _("{standard input}")) == 0
336 && input_line_pointer != NULL)
338 char *copy;
339 int len;
340 int seen_quote = 0;
341 int seen_slash = 0;
343 for (copy = input_line_pointer - 1;
344 *copy && (seen_quote
345 || is_end_of_line [(unsigned char) *copy] != 1);
346 copy++)
348 if (*copy == '\\')
349 seen_slash = ! seen_slash;
350 else if (*copy == '"' && seen_slash)
351 seen_quote = ! seen_quote;
354 len = (copy - input_line_pointer) + 2;
356 copy = xmalloc (len);
358 if (copy != NULL)
360 char *src = input_line_pointer - 1;
361 char *dest = copy;
363 while (--len)
365 unsigned char c = *src++;
367 /* Omit control characters in the listing. */
368 if (!ISCNTRL (c))
369 *dest++ = c;
372 *dest = 0;
375 new->line_contents = copy;
377 else
378 new->line_contents = NULL;
380 else
382 new = xmalloc (sizeof (list_info_type));
383 new->line_contents = ps;
386 last_line = line;
387 last_file = file;
389 new_frag ();
391 if (listing_tail)
392 listing_tail->next = new;
393 else
394 head = new;
396 listing_tail = new;
398 new->frag = frag_now;
399 new->line = line;
400 new->file = file_info (file);
401 new->next = (list_info_type *) NULL;
402 new->message = (char *) NULL;
403 new->edict = EDICT_NONE;
404 new->hll_file = (file_info_type *) NULL;
405 new->hll_line = 0;
406 new->debugging = 0;
408 new_frag ();
410 #ifdef OBJ_ELF
411 /* In ELF, anything in a section beginning with .debug or .line is
412 considered to be debugging information. */
413 if ((listing & LISTING_NODEBUG) != 0)
415 const char *segname;
417 segname = segment_name (now_seg);
418 if (strncmp (segname, ".debug", sizeof ".debug" - 1) == 0
419 || strncmp (segname, ".line", sizeof ".line" - 1) == 0)
420 new->debugging = 1;
422 #endif
425 /* Attach all current frags to the previous line instead of the
426 current line. This is called by the MIPS backend when it discovers
427 that it needs to add some NOP instructions; the added NOP
428 instructions should go with the instruction that has the delay, not
429 with the new instruction. */
431 void
432 listing_prev_line (void)
434 list_info_type *l;
435 fragS *f;
437 if (head == (list_info_type *) NULL
438 || head == listing_tail)
439 return;
441 new_frag ();
443 for (l = head; l->next != listing_tail; l = l->next)
446 for (f = frchain_now->frch_root; f != (fragS *) NULL; f = f->fr_next)
447 if (f->line == listing_tail)
448 f->line = l;
450 listing_tail->frag = frag_now;
451 new_frag ();
454 /* This function returns the next source line from the file supplied,
455 truncated to size. It appends a fake line to the end of each input
456 file to make. */
458 static char *
459 buffer_line (file_info_type *file, char *line, unsigned int size)
461 unsigned int count = 0;
462 int c;
464 char *p = line;
466 /* If we couldn't open the file, return an empty line. */
467 if (file->at_end)
468 return "";
470 /* Check the cache and see if we last used this file. */
471 if (!last_open_file_info || file != last_open_file_info)
473 if (last_open_file)
475 last_open_file_info->pos = ftell (last_open_file);
476 fclose (last_open_file);
479 /* Open the file in the binary mode so that ftell above can
480 return a reliable value that we can feed to fseek below. */
481 last_open_file_info = file;
482 last_open_file = fopen (file->filename, FOPEN_RB);
483 if (last_open_file == NULL)
485 file->at_end = 1;
486 return "";
489 /* Seek to where we were last time this file was open. */
490 if (file->pos)
491 fseek (last_open_file, file->pos, SEEK_SET);
494 c = fgetc (last_open_file);
496 /* Leave room for null. */
497 size -= 1;
499 while (c != EOF && c != '\n' && c != '\r')
501 if (count < size)
502 *p++ = c;
503 count++;
505 c = fgetc (last_open_file);
509 /* If '\r' is followed by '\n', swallow that. Likewise, if '\n'
510 is followed by '\r', swallow that as well. */
511 if (c == '\r' || c == '\n')
513 int next = fgetc (last_open_file);
514 if ((c == '\r' && next != '\n')
515 || (c == '\n' && next != '\r'))
516 ungetc (next, last_open_file);
519 if (c == EOF)
521 file->at_end = 1;
522 if (count + 2 < size)
524 *p++ = '.';
525 *p++ = '.';
526 *p++ = '.';
529 file->linenum++;
530 *p++ = 0;
531 return line;
534 static const char *fn;
536 static unsigned int eject; /* Eject pending */
537 static unsigned int page; /* Current page number */
538 static char *title; /* Current title */
539 static char *subtitle; /* Current subtitle */
540 static unsigned int on_page; /* Number of lines printed on current page */
542 static void
543 listing_page (list_info_type *list)
545 /* Grope around, see if we can see a title or subtitle edict coming up
546 soon. (we look down 10 lines of the page and see if it's there) */
547 if ((eject || (on_page >= (unsigned int) paper_height))
548 && paper_height != 0)
550 unsigned int c = 10;
551 int had_title = 0;
552 int had_subtitle = 0;
554 page++;
556 while (c != 0 && list)
558 if (list->edict == EDICT_SBTTL && !had_subtitle)
560 had_subtitle = 1;
561 subtitle = list->edict_arg;
563 if (list->edict == EDICT_TITLE && !had_title)
565 had_title = 1;
566 title = list->edict_arg;
568 list = list->next;
569 c--;
572 if (page > 1)
574 fprintf (list_file, "\f");
577 fprintf (list_file, "%s %s \t\t\tpage %d\n", LISTING_HEADER, fn, page);
578 fprintf (list_file, "%s\n", title);
579 fprintf (list_file, "%s\n", subtitle);
580 on_page = 3;
581 eject = 0;
585 static unsigned int
586 calc_hex (list_info_type *list)
588 int data_buffer_size;
589 list_info_type *first = list;
590 unsigned int address = ~(unsigned int) 0;
591 fragS *frag;
592 fragS *frag_ptr;
593 unsigned int octet_in_frag;
595 /* Find first frag which says it belongs to this line. */
596 frag = list->frag;
597 while (frag && frag->line != list)
598 frag = frag->fr_next;
600 frag_ptr = frag;
602 data_buffer_size = 0;
604 /* Dump all the frags which belong to this line. */
605 while (frag_ptr != (fragS *) NULL && frag_ptr->line == first)
607 /* Print as many bytes from the fixed part as is sensible. */
608 octet_in_frag = 0;
609 while ((offsetT) octet_in_frag < frag_ptr->fr_fix
610 && data_buffer_size < MAX_BYTES - 3)
612 if (address == ~(unsigned int) 0)
613 address = frag_ptr->fr_address / OCTETS_PER_BYTE;
615 sprintf (data_buffer + data_buffer_size,
616 "%02X",
617 (frag_ptr->fr_literal[octet_in_frag]) & 0xff);
618 data_buffer_size += 2;
619 octet_in_frag++;
621 if (frag_ptr->fr_type == rs_fill)
623 unsigned int var_rep_max = octet_in_frag;
624 unsigned int var_rep_idx = octet_in_frag;
626 /* Print as many bytes from the variable part as is sensible. */
627 while (((offsetT) octet_in_frag
628 < (frag_ptr->fr_fix + frag_ptr->fr_var * frag_ptr->fr_offset))
629 && data_buffer_size < MAX_BYTES - 3)
631 if (address == ~(unsigned int) 0)
632 address = frag_ptr->fr_address / OCTETS_PER_BYTE;
634 sprintf (data_buffer + data_buffer_size,
635 "%02X",
636 (frag_ptr->fr_literal[var_rep_idx]) & 0xff);
637 data_buffer_size += 2;
639 var_rep_idx++;
640 octet_in_frag++;
642 if ((offsetT) var_rep_idx >= frag_ptr->fr_fix + frag_ptr->fr_var)
643 var_rep_idx = var_rep_max;
647 frag_ptr = frag_ptr->fr_next;
649 data_buffer[data_buffer_size] = '\0';
650 return address;
653 static void
654 print_lines (list_info_type *list, unsigned int lineno,
655 char *string, unsigned int address)
657 unsigned int idx;
658 unsigned int nchars;
659 unsigned int lines;
660 unsigned int octet_in_word = 0;
661 char *src = data_buffer;
662 int cur;
664 /* Print the stuff on the first line. */
665 listing_page (list);
666 nchars = (LISTING_WORD_SIZE * 2 + 1) * listing_lhs_width;
668 /* Print the hex for the first line. */
669 if (address == ~(unsigned int) 0)
671 fprintf (list_file, "% 4d ", lineno);
672 for (idx = 0; idx < nchars; idx++)
673 fprintf (list_file, " ");
675 fprintf (list_file, "\t%s\n", string ? string : "");
677 on_page++;
679 listing_page (0);
681 return;
684 if (had_errors ())
685 fprintf (list_file, "% 4d ???? ", lineno);
686 else
687 fprintf (list_file, "% 4d %04x ", lineno, address);
689 /* And the data to go along with it. */
690 idx = 0;
691 cur = 0;
692 while (src[cur] && idx < nchars)
694 int offset;
695 offset = cur;
696 fprintf (list_file, "%c%c", src[offset], src[offset + 1]);
697 cur += 2;
698 octet_in_word++;
700 if (octet_in_word == LISTING_WORD_SIZE)
702 fprintf (list_file, " ");
703 idx++;
704 octet_in_word = 0;
707 idx += 2;
710 for (; idx < nchars; idx++)
711 fprintf (list_file, " ");
713 fprintf (list_file, "\t%s\n", string ? string : "");
714 on_page++;
715 listing_page (list);
717 if (list->message)
719 fprintf (list_file, "**** %s\n", list->message);
720 listing_page (list);
721 on_page++;
724 for (lines = 0;
725 lines < (unsigned int) listing_lhs_cont_lines
726 && src[cur];
727 lines++)
729 nchars = ((LISTING_WORD_SIZE * 2) + 1) * listing_lhs_width_second - 1;
730 idx = 0;
732 /* Print any more lines of data, but more compactly. */
733 fprintf (list_file, "% 4d ", lineno);
735 while (src[cur] && idx < nchars)
737 int offset;
738 offset = cur;
739 fprintf (list_file, "%c%c", src[offset], src[offset + 1]);
740 cur += 2;
741 idx += 2;
742 octet_in_word++;
744 if (octet_in_word == LISTING_WORD_SIZE)
746 fprintf (list_file, " ");
747 idx++;
748 octet_in_word = 0;
752 fprintf (list_file, "\n");
753 on_page++;
754 listing_page (list);
758 static void
759 list_symbol_table (void)
761 extern symbolS *symbol_rootP;
762 int got_some = 0;
764 symbolS *ptr;
765 eject = 1;
766 listing_page (0);
768 for (ptr = symbol_rootP; ptr != (symbolS *) NULL; ptr = symbol_next (ptr))
770 if (SEG_NORMAL (S_GET_SEGMENT (ptr))
771 || S_GET_SEGMENT (ptr) == absolute_section)
773 /* Don't report section symbols. They are not interesting. */
774 if (symbol_section_p (ptr))
775 continue;
777 if (S_GET_NAME (ptr))
779 char buf[30], fmt[8];
780 valueT val = S_GET_VALUE (ptr);
782 /* @@ Note that this is dependent on the compilation options,
783 not solely on the target characteristics. */
784 if (sizeof (val) == 4 && sizeof (int) == 4)
785 sprintf (buf, "%08lx", (unsigned long) val);
786 else if (sizeof (val) <= sizeof (unsigned long))
788 sprintf (fmt, "%%0%lulx",
789 (unsigned long) (sizeof (val) * 2));
790 sprintf (buf, fmt, (unsigned long) val);
792 #if defined (BFD64)
793 else if (sizeof (val) > 4)
794 sprintf_vma (buf, val);
795 #endif
796 else
797 abort ();
799 if (!got_some)
801 fprintf (list_file, "DEFINED SYMBOLS\n");
802 on_page++;
803 got_some = 1;
806 if (symbol_get_frag (ptr) && symbol_get_frag (ptr)->line)
808 fprintf (list_file, "%20s:%-5d %s:%s %s\n",
809 symbol_get_frag (ptr)->line->file->filename,
810 symbol_get_frag (ptr)->line->line,
811 segment_name (S_GET_SEGMENT (ptr)),
812 buf, S_GET_NAME (ptr));
814 else
816 fprintf (list_file, "%33s:%s %s\n",
817 segment_name (S_GET_SEGMENT (ptr)),
818 buf, S_GET_NAME (ptr));
821 on_page++;
822 listing_page (0);
827 if (!got_some)
829 fprintf (list_file, "NO DEFINED SYMBOLS\n");
830 on_page++;
832 fprintf (list_file, "\n");
833 on_page++;
834 listing_page (0);
836 got_some = 0;
838 for (ptr = symbol_rootP; ptr != (symbolS *) NULL; ptr = symbol_next (ptr))
840 if (S_GET_NAME (ptr) && strlen (S_GET_NAME (ptr)) != 0)
842 if (S_GET_SEGMENT (ptr) == undefined_section)
844 if (!got_some)
846 got_some = 1;
847 fprintf (list_file, "UNDEFINED SYMBOLS\n");
848 on_page++;
849 listing_page (0);
851 fprintf (list_file, "%s\n", S_GET_NAME (ptr));
852 on_page++;
853 listing_page (0);
857 if (!got_some)
859 fprintf (list_file, "NO UNDEFINED SYMBOLS\n");
860 on_page++;
861 listing_page (0);
865 static void
866 print_source (file_info_type *current_file, list_info_type *list,
867 char *buffer, unsigned int width)
869 if (!current_file->at_end)
871 while (current_file->linenum < list->hll_line
872 && !current_file->at_end)
874 char *p = buffer_line (current_file, buffer, width);
876 fprintf (list_file, "%4u:%-13s **** %s\n", current_file->linenum,
877 current_file->filename, p);
878 on_page++;
879 listing_page (list);
884 /* Sometimes the user doesn't want to be bothered by the debugging
885 records inserted by the compiler, see if the line is suspicious. */
887 static int
888 debugging_pseudo (list_info_type *list, const char *line)
890 static int in_debug;
891 int was_debug;
893 if (list->debugging)
895 in_debug = 1;
896 return 1;
899 was_debug = in_debug;
900 in_debug = 0;
902 while (ISSPACE (*line))
903 line++;
905 if (*line != '.')
907 #ifdef OBJ_ELF
908 /* The ELF compiler sometimes emits blank lines after switching
909 out of a debugging section. If the next line drops us back
910 into debugging information, then don't print the blank line.
911 This is a hack for a particular compiler behaviour, not a
912 general case. */
913 if (was_debug
914 && *line == '\0'
915 && list->next != NULL
916 && list->next->debugging)
918 in_debug = 1;
919 return 1;
921 #endif
923 return 0;
926 line++;
928 if (strncmp (line, "def", 3) == 0)
929 return 1;
930 if (strncmp (line, "val", 3) == 0)
931 return 1;
932 if (strncmp (line, "scl", 3) == 0)
933 return 1;
934 if (strncmp (line, "line", 4) == 0)
935 return 1;
936 if (strncmp (line, "endef", 5) == 0)
937 return 1;
938 if (strncmp (line, "ln", 2) == 0)
939 return 1;
940 if (strncmp (line, "type", 4) == 0)
941 return 1;
942 if (strncmp (line, "size", 4) == 0)
943 return 1;
944 if (strncmp (line, "dim", 3) == 0)
945 return 1;
946 if (strncmp (line, "tag", 3) == 0)
947 return 1;
948 if (strncmp (line, "stabs", 5) == 0)
949 return 1;
950 if (strncmp (line, "stabn", 5) == 0)
951 return 1;
953 return 0;
956 static void
957 listing_listing (char *name ATTRIBUTE_UNUSED)
959 list_info_type *list = head;
960 file_info_type *current_hll_file = (file_info_type *) NULL;
961 char *message;
962 char *buffer;
963 char *p;
964 int show_listing = 1;
965 unsigned int width;
967 buffer = xmalloc (listing_rhs_width);
968 data_buffer = xmalloc (MAX_BYTES);
969 eject = 1;
970 list = head->next;
972 while (list)
974 unsigned int list_line;
976 width = listing_rhs_width > paper_width ? paper_width :
977 listing_rhs_width;
979 list_line = list->line;
980 switch (list->edict)
982 case EDICT_LIST:
983 /* Skip all lines up to the current. */
984 list_line--;
985 break;
986 case EDICT_NOLIST:
987 show_listing--;
988 break;
989 case EDICT_NOLIST_NEXT:
990 if (show_listing == 0)
991 list_line--;
992 break;
993 case EDICT_EJECT:
994 break;
995 case EDICT_NONE:
996 break;
997 case EDICT_TITLE:
998 title = list->edict_arg;
999 break;
1000 case EDICT_SBTTL:
1001 subtitle = list->edict_arg;
1002 break;
1003 default:
1004 abort ();
1007 if (show_listing <= 0)
1009 while (list->file->linenum < list_line
1010 && !list->file->at_end)
1011 p = buffer_line (list->file, buffer, width);
1014 if (list->edict == EDICT_LIST
1015 || (list->edict == EDICT_NOLIST_NEXT && show_listing == 0))
1017 /* Enable listing for the single line that caused the enable. */
1018 list_line++;
1019 show_listing++;
1022 if (show_listing > 0)
1024 /* Scan down the list and print all the stuff which can be done
1025 with this line (or lines). */
1026 message = 0;
1028 if (list->hll_file)
1029 current_hll_file = list->hll_file;
1031 if (current_hll_file && list->hll_line && (listing & LISTING_HLL))
1032 print_source (current_hll_file, list, buffer, width);
1034 if (list->line_contents)
1036 if (!((listing & LISTING_NODEBUG)
1037 && debugging_pseudo (list, list->line_contents)))
1038 print_lines (list,
1039 list->file->linenum == 0 ? list->line : list->file->linenum,
1040 list->line_contents, calc_hex (list));
1042 free (list->line_contents);
1043 list->line_contents = NULL;
1045 else
1047 while (list->file->linenum < list_line
1048 && !list->file->at_end)
1050 unsigned int address;
1052 p = buffer_line (list->file, buffer, width);
1054 if (list->file->linenum < list_line)
1055 address = ~(unsigned int) 0;
1056 else
1057 address = calc_hex (list);
1059 if (!((listing & LISTING_NODEBUG)
1060 && debugging_pseudo (list, p)))
1061 print_lines (list, list->file->linenum, p, address);
1065 if (list->edict == EDICT_EJECT)
1066 eject = 1;
1069 if (list->edict == EDICT_NOLIST_NEXT && show_listing == 1)
1070 --show_listing;
1072 list = list->next;
1075 free (buffer);
1076 free (data_buffer);
1077 data_buffer = NULL;
1080 /* Print time stamp in ISO format: yyyy-mm-ddThh:mm:ss.ss+/-zzzz. */
1082 static void
1083 print_timestamp (void)
1085 const time_t now = time (NULL);
1086 struct tm * timestamp;
1087 char stampstr[MAX_DATELEN];
1089 /* Any portable way to obtain subsecond values??? */
1090 timestamp = localtime (&now);
1091 strftime (stampstr, MAX_DATELEN, "%Y-%m-%dT%H:%M:%S.000%z", timestamp);
1092 fprintf (list_file, _("\n time stamp \t: %s\n\n"), stampstr);
1095 static void
1096 print_single_option (char * opt, int *pos)
1098 int opt_len = strlen (opt);
1100 if ((*pos + opt_len) < paper_width)
1102 fprintf (list_file, _("%s "), opt);
1103 *pos = *pos + opt_len;
1105 else
1107 fprintf (list_file, _("\n\t%s "), opt);
1108 *pos = opt_len;
1112 /* Print options passed to as. */
1114 static void
1115 print_options (char ** argv)
1117 const char *field_name = _("\n options passed\t: ");
1118 int pos = strlen (field_name);
1119 char **p;
1121 fputs (field_name, list_file);
1122 for (p = &argv[1]; *p != NULL; p++)
1123 if (**p == '-')
1125 /* Ignore these. */
1126 if (strcmp (*p, "-o") == 0)
1128 if (p[1] != NULL)
1129 p++;
1130 continue;
1132 if (strcmp (*p, "-v") == 0)
1133 continue;
1135 print_single_option (*p, &pos);
1139 /* Print a first section with basic info like file names, as version,
1140 options passed, target, and timestamp.
1141 The format of this section is as follows:
1143 AS VERSION
1145 fieldname TAB ':' fieldcontents
1146 { TAB fieldcontents-cont } */
1148 static void
1149 listing_general_info (char ** argv)
1151 /* Print the stuff on the first line. */
1152 eject = 1;
1153 listing_page (0);
1155 fprintf (list_file,
1156 _(" GNU assembler version %s (%s)\n\t using BFD version %s."),
1157 VERSION, TARGET_ALIAS, BFD_VERSION_STRING);
1158 print_options (argv);
1159 fprintf (list_file, _("\n input file \t: %s"), fn);
1160 fprintf (list_file, _("\n output file \t: %s"), out_file_name);
1161 fprintf (list_file, _("\n target \t: %s"), TARGET_CANONICAL);
1162 print_timestamp ();
1165 void
1166 listing_print (char *name, char **argv)
1168 int using_stdout;
1170 title = "";
1171 subtitle = "";
1173 if (name == NULL)
1175 list_file = stdout;
1176 using_stdout = 1;
1178 else
1180 list_file = fopen (name, FOPEN_WT);
1181 if (list_file != NULL)
1182 using_stdout = 0;
1183 else
1185 as_warn (_("can't open %s: %s"), name, xstrerror (errno));
1186 list_file = stdout;
1187 using_stdout = 1;
1191 if (listing & LISTING_NOFORM)
1192 paper_height = 0;
1194 if (listing & LISTING_GENERAL)
1195 listing_general_info (argv);
1197 if (listing & LISTING_LISTING)
1198 listing_listing (name);
1200 if (listing & LISTING_SYMBOLS)
1201 list_symbol_table ();
1203 if (! using_stdout)
1205 if (fclose (list_file) == EOF)
1206 as_warn (_("can't close %s: %s"), name, xstrerror (errno));
1209 if (last_open_file)
1210 fclose (last_open_file);
1213 void
1214 listing_file (const char *name)
1216 fn = name;
1219 void
1220 listing_eject (int ignore ATTRIBUTE_UNUSED)
1222 if (listing)
1223 listing_tail->edict = EDICT_EJECT;
1226 void
1227 listing_flags (int ignore ATTRIBUTE_UNUSED)
1229 while ((*input_line_pointer++) && (*input_line_pointer != '\n'))
1230 input_line_pointer++;
1234 /* Turn listing on or off. An argument of 0 means to turn off
1235 listing. An argument of 1 means to turn on listing. An argument
1236 of 2 means to turn off listing, but as of the next line; that is,
1237 the current line should be listed, but the next line should not. */
1239 void
1240 listing_list (int on)
1242 if (listing)
1244 switch (on)
1246 case 0:
1247 if (listing_tail->edict == EDICT_LIST)
1248 listing_tail->edict = EDICT_NONE;
1249 else
1250 listing_tail->edict = EDICT_NOLIST;
1251 break;
1252 case 1:
1253 if (listing_tail->edict == EDICT_NOLIST
1254 || listing_tail->edict == EDICT_NOLIST_NEXT)
1255 listing_tail->edict = EDICT_NONE;
1256 else
1257 listing_tail->edict = EDICT_LIST;
1258 break;
1259 case 2:
1260 listing_tail->edict = EDICT_NOLIST_NEXT;
1261 break;
1262 default:
1263 abort ();
1268 void
1269 listing_psize (int width_only)
1271 if (! width_only)
1273 paper_height = get_absolute_expression ();
1275 if (paper_height < 0 || paper_height > 1000)
1277 paper_height = 0;
1278 as_warn (_("strange paper height, set to no form"));
1281 if (*input_line_pointer != ',')
1283 demand_empty_rest_of_line ();
1284 return;
1287 ++input_line_pointer;
1290 paper_width = get_absolute_expression ();
1292 demand_empty_rest_of_line ();
1295 void
1296 listing_nopage (int ignore ATTRIBUTE_UNUSED)
1298 paper_height = 0;
1301 void
1302 listing_title (int depth)
1304 int quoted;
1305 char *start;
1306 char *ttl;
1307 unsigned int length;
1309 SKIP_WHITESPACE ();
1310 if (*input_line_pointer != '\"')
1311 quoted = 0;
1312 else
1314 quoted = 1;
1315 ++input_line_pointer;
1318 start = input_line_pointer;
1320 while (*input_line_pointer)
1322 if (quoted
1323 ? *input_line_pointer == '\"'
1324 : is_end_of_line[(unsigned char) *input_line_pointer])
1326 if (listing)
1328 length = input_line_pointer - start;
1329 ttl = xmalloc (length + 1);
1330 memcpy (ttl, start, length);
1331 ttl[length] = 0;
1332 listing_tail->edict = depth ? EDICT_SBTTL : EDICT_TITLE;
1333 listing_tail->edict_arg = ttl;
1335 if (quoted)
1336 input_line_pointer++;
1337 demand_empty_rest_of_line ();
1338 return;
1340 else if (*input_line_pointer == '\n')
1342 as_bad (_("new line in title"));
1343 demand_empty_rest_of_line ();
1344 return;
1346 else
1348 input_line_pointer++;
1353 void
1354 listing_source_line (unsigned int line)
1356 if (listing)
1358 new_frag ();
1359 listing_tail->hll_line = line;
1360 new_frag ();
1364 void
1365 listing_source_file (const char *file)
1367 if (listing)
1368 listing_tail->hll_file = file_info (file);
1371 #else
1373 /* Dummy functions for when compiled without listing enabled. */
1375 void
1376 listing_flags (int ignore)
1378 s_ignore (0);
1381 void
1382 listing_list (int on)
1384 s_ignore (0);
1387 void
1388 listing_eject (int ignore)
1390 s_ignore (0);
1393 void
1394 listing_psize (int ignore)
1396 s_ignore (0);
1399 void
1400 listing_nopage (int ignore)
1402 s_ignore (0);
1405 void
1406 listing_title (int depth)
1408 s_ignore (0);
1411 void
1412 listing_file (const char *name)
1416 void
1417 listing_newline (char *name)
1421 void
1422 listing_source_line (unsigned int n)
1426 void
1427 listing_source_file (const char *n)
1431 #endif