1 /* listing.c - maintain assembly listings
2 Copyright (C) 1991-2016 Free Software Foundation, Inc.
4 This file is part of GAS, the GNU Assembler.
6 GAS is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
11 GAS is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GAS; see the file COPYING. If not, write to the Free
18 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
21 /* Contributed by Steve Chamberlain <sac@cygnus.com>
23 A listing page looks like:
25 LISTING_HEADER sourcefilename pagenumber
28 linenumber address data source
29 linenumber address data source
30 linenumber address data source
31 linenumber address data source
33 If not overridden, the listing commands are:
36 Put "stuff" onto the title line
38 Put stuff onto the subtitle line
40 If these commands come within 10 lines of the top of the page, they
41 will affect the page they are on, as well as any subsequent page
46 Increment the enable listing counter
48 Decrement the enable listing counter
51 Set the paper size to X wide and Y high. Setting a psize Y of
52 zero will suppress form feeds except where demanded by .eject
54 If the counter goes below zero, listing is suppressed.
56 Listings are a maintained by read calling various listing_<foo>
57 functions. What happens most is that the macro NO_LISTING is not
58 defined (from the Makefile), then the macro LISTING_NEWLINE expands
59 into a call to listing_newline. The call is done from read.c, every
60 time it sees a newline, and -l is on the command line.
62 The function listing_newline remembers the frag associated with the
63 newline, and creates a new frag - note that this is wasteful, but not
64 a big deal, since listing slows things down a lot anyway. The
65 function also remembers when the filename changes.
67 When all the input has finished, and gas has had a chance to settle
68 down, the listing is output. This is done by running down the list of
69 frag/source file records, and opening the files as needed and printing
70 out the bytes and chars associated with them.
72 The only things which the architecture can change about the listing
73 are defined in these macros:
75 LISTING_HEADER The name of the architecture
76 LISTING_WORD_SIZE The make of the number of bytes in a word, this determines
77 the clumping of the output data. eg a value of
78 2 makes words look like 1234 5678, whilst 1
79 would make the same value look like 12 34 56
81 LISTING_LHS_WIDTH Number of words of above size for the lhs
83 LISTING_LHS_WIDTH_SECOND Number of words for the data on the lhs
86 LISTING_LHS_CONT_LINES Max number of lines to use up for a continuation
87 LISTING_RHS_WIDTH Number of chars from the input file to print
91 #include "filenames.h"
92 #include "safe-ctype.h"
93 #include "input-file.h"
101 #ifndef LISTING_HEADER
102 #define LISTING_HEADER "GAS LISTING"
104 #ifndef LISTING_WORD_SIZE
105 #define LISTING_WORD_SIZE 4
107 #ifndef LISTING_LHS_WIDTH
108 #define LISTING_LHS_WIDTH ((LISTING_WORD_SIZE) > 4 ? 1 : 4 / (LISTING_WORD_SIZE))
110 #ifndef LISTING_LHS_WIDTH_SECOND
111 #define LISTING_LHS_WIDTH_SECOND LISTING_LHS_WIDTH
113 #ifndef LISTING_RHS_WIDTH
114 #define LISTING_RHS_WIDTH 100
116 #ifndef LISTING_LHS_CONT_LINES
117 #define LISTING_LHS_CONT_LINES 4
119 #define MAX_DATELEN 30
121 /* This structure remembers which .s were used. */
122 typedef struct file_info_struct
124 struct file_info_struct * next;
127 unsigned int linenum;
146 struct list_message *next;
149 /* This structure remembers which line from which file goes into which
151 struct list_info_struct
153 /* Frag which this line of source is nearest to. */
156 /* The actual line in the source file. */
159 /* Pointer to the file info struct for the file which this line
161 file_info_type *file;
163 /* The expanded text of any macro that may have been executing. */
167 struct list_info_struct *next;
169 /* Pointer to the file info struct for the high level language
170 source line that belongs here. */
171 file_info_type *hll_file;
173 /* High level language source line. */
174 unsigned int hll_line;
176 /* Pointers to linked list of messages associated with this line. */
177 struct list_message *messages, *last_message;
179 enum edict_enum edict;
182 /* Nonzero if this line is to be omitted because it contains
183 debugging information. This can become a flags field if we come
184 up with more information to store here. */
188 typedef struct list_info_struct list_info_type;
190 int listing_lhs_width = LISTING_LHS_WIDTH;
191 int listing_lhs_width_second = LISTING_LHS_WIDTH_SECOND;
192 int listing_lhs_cont_lines = LISTING_LHS_CONT_LINES;
193 int listing_rhs_width = LISTING_RHS_WIDTH;
195 struct list_info_struct * listing_tail;
197 static file_info_type * file_info_head;
198 static file_info_type * last_open_file_info;
199 static FILE * last_open_file;
200 static struct list_info_struct * head;
201 static int paper_width = 200;
202 static int paper_height = 60;
206 /* File to output listings to. */
207 static FILE *list_file;
209 /* This static array is used to keep the text of data to be printed
210 before the start of the line. */
213 (((LISTING_WORD_SIZE * 2) + 1) * listing_lhs_width \
214 + ((((LISTING_WORD_SIZE * 2) + 1) * listing_lhs_width_second) \
215 * listing_lhs_cont_lines) \
218 static char *data_buffer;
221 static void listing_message (const char *, const char *);
222 static file_info_type *file_info (const char *);
223 static void new_frag (void);
224 static void listing_page (list_info_type *);
225 static unsigned int calc_hex (list_info_type *);
226 static void print_lines (list_info_type *, unsigned int, const char *,
228 static void list_symbol_table (void);
229 static int debugging_pseudo (list_info_type *, const char *);
230 static void listing_listing (char *);
233 listing_message (const char *name, const char *message)
235 if (listing_tail != (list_info_type *) NULL)
237 unsigned int l = strlen (name) + strlen (message) + 1;
238 char *n = (char *) xmalloc (l);
239 struct list_message *lm = xmalloc (sizeof *lm);
245 if (listing_tail->last_message)
246 listing_tail->last_message->next = lm;
248 listing_tail->messages = lm;
249 listing_tail->last_message = lm;
254 listing_warning (const char *message)
256 listing_message (_("Warning: "), message);
260 listing_error (const char *message)
262 listing_message (_("Error: "), message);
265 static file_info_type *
266 file_info (const char *file_name)
268 /* Find an entry with this file name. */
269 file_info_type *p = file_info_head;
271 while (p != (file_info_type *) NULL)
273 if (filename_cmp (p->filename, file_name) == 0)
278 /* Make new entry. */
279 p = (file_info_type *) xmalloc (sizeof (file_info_type));
280 p->next = file_info_head;
282 p->filename = xstrdup (file_name);
293 frag_wane (frag_now);
298 listing_newline (char *ps)
302 static unsigned int last_line = 0xffff;
303 static const char *last_file = NULL;
304 list_info_type *new_i = NULL;
309 if (now_seg == absolute_section)
313 /* In ELF, anything in a section beginning with .debug or .line is
314 considered to be debugging information. This includes the
315 statement which switches us into the debugging section, which we
316 can only set after we are already in the debugging section. */
317 if ((listing & LISTING_NODEBUG) != 0
318 && listing_tail != NULL
319 && ! listing_tail->debugging)
323 segname = segment_name (now_seg);
324 if (strncmp (segname, ".debug", sizeof ".debug" - 1) == 0
325 || strncmp (segname, ".line", sizeof ".line" - 1) == 0)
326 listing_tail->debugging = 1;
330 file = as_where (&line);
333 if (line == last_line
334 && !(last_file && file && filename_cmp (file, last_file)))
337 new_i = (list_info_type *) xmalloc (sizeof (list_info_type));
339 /* Detect if we are reading from stdin by examining the file
340 name returned by as_where().
342 [FIXME: We rely upon the name in the strcmp below being the
343 same as the one used by input_scrub_new_file(), if that is
344 not true, then this code will fail].
346 If we are reading from stdin, then we need to save each input
347 line here (assuming of course that we actually have a line of
348 input to read), so that it can be displayed in the listing
349 that is produced at the end of the assembly. */
350 if (strcmp (file, _("{standard input}")) == 0
351 && input_line_pointer != NULL)
358 for (copy = input_line_pointer;
360 || is_end_of_line [(unsigned char) *copy] != 1);
365 else if (*copy == '\\')
367 else if (*copy == '"')
368 seen_quote = !seen_quote;
371 len = copy - input_line_pointer + 1;
373 copy = (char *) xmalloc (len);
377 char *src = input_line_pointer;
382 unsigned char c = *src++;
384 /* Omit control characters in the listing. */
392 new_i->line_contents = copy;
395 new_i->line_contents = NULL;
399 new_i = (list_info_type *) xmalloc (sizeof (list_info_type));
400 new_i->line_contents = ps;
409 listing_tail->next = new_i;
413 listing_tail = new_i;
415 new_i->frag = frag_now;
417 new_i->file = file_info (file);
418 new_i->next = (list_info_type *) NULL;
419 new_i->messages = NULL;
420 new_i->last_message = NULL;
421 new_i->edict = EDICT_NONE;
422 new_i->hll_file = (file_info_type *) NULL;
424 new_i->debugging = 0;
429 /* In ELF, anything in a section beginning with .debug or .line is
430 considered to be debugging information. */
431 if ((listing & LISTING_NODEBUG) != 0)
435 segname = segment_name (now_seg);
436 if (strncmp (segname, ".debug", sizeof ".debug" - 1) == 0
437 || strncmp (segname, ".line", sizeof ".line" - 1) == 0)
438 new_i->debugging = 1;
443 /* Attach all current frags to the previous line instead of the
444 current line. This is called by the MIPS backend when it discovers
445 that it needs to add some NOP instructions; the added NOP
446 instructions should go with the instruction that has the delay, not
447 with the new instruction. */
450 listing_prev_line (void)
455 if (head == (list_info_type *) NULL
456 || head == listing_tail)
461 for (l = head; l->next != listing_tail; l = l->next)
464 for (f = frchain_now->frch_root; f != (fragS *) NULL; f = f->fr_next)
465 if (f->line == listing_tail)
468 listing_tail->frag = frag_now;
472 /* This function returns the next source line from the file supplied,
473 truncated to size. It appends a fake line to the end of each input
474 file to make using the returned buffer simpler. */
477 buffer_line (file_info_type *file, char *line, unsigned int size)
479 unsigned int count = 0;
483 /* If we couldn't open the file, return an empty line. */
487 /* Check the cache and see if we last used this file. */
488 if (!last_open_file_info || file != last_open_file_info)
492 last_open_file_info->pos = ftell (last_open_file);
493 fclose (last_open_file);
496 /* Open the file in the binary mode so that ftell above can
497 return a reliable value that we can feed to fseek below. */
498 last_open_file_info = file;
499 last_open_file = fopen (file->filename, FOPEN_RB);
500 if (last_open_file == NULL)
506 /* Seek to where we were last time this file was open. */
508 fseek (last_open_file, file->pos, SEEK_SET);
511 /* Leave room for null. */
514 c = fgetc (last_open_file);
516 while (c != EOF && c != '\n' && c != '\r')
522 c = fgetc (last_open_file);
525 /* If '\r' is followed by '\n', swallow that. Likewise, if '\n'
526 is followed by '\r', swallow that as well. */
527 if (c == '\r' || c == '\n')
529 int next = fgetc (last_open_file);
531 if ((c == '\r' && next != '\n')
532 || (c == '\n' && next != '\r'))
533 ungetc (next, last_open_file);
539 if (count + 2 < size)
552 /* This function rewinds the requested file back to the line requested,
553 reads it in again into the buffer provided and then restores the file
554 back to its original location. */
557 rebuffer_line (file_info_type * file,
558 unsigned int linenum,
562 unsigned int count = 0;
563 unsigned int current_line;
568 bfd_boolean found = FALSE;
571 if (file == NULL || buffer == NULL || size <= 1 || file->linenum <= linenum)
574 /* Check the cache and see if we last used this file. */
575 if (last_open_file_info == NULL || file != last_open_file_info)
579 last_open_file_info->pos = ftell (last_open_file);
580 fclose (last_open_file);
583 /* Open the file in the binary mode so that ftell above can
584 return a reliable value that we can feed to fseek below. */
585 last_open_file_info = file;
586 last_open_file = fopen (file->filename, FOPEN_RB);
587 if (last_open_file == NULL)
593 /* Seek to where we were last time this file was open. */
595 fseek (last_open_file, file->pos, SEEK_SET);
598 /* Remember where we are in the current file. */
599 pos2 = pos = ftell (last_open_file);
602 current_line = file->linenum;
604 /* Leave room for the nul at the end of the buffer. */
608 /* Increment the current line count by one.
609 This is to allow for the fact that we are searching for the
610 start of a previous line, but we do this by detecting end-of-line
611 character(s) not start-of-line characters. */
614 while (pos2 > 0 && ! found)
618 /* Move backwards through the file, looking for earlier lines. */
619 pos2 = (long) size > pos2 ? 0 : pos2 - size;
620 fseek (last_open_file, pos2, SEEK_SET);
622 /* Our caller has kindly provided us with a buffer, so we use it. */
623 if (fread (buffer, 1, size, last_open_file) != size)
625 as_warn (_("unable to rebuffer file: %s\n"), file->filename);
629 for (ptr = buffer + size; ptr >= buffer; -- ptr)
635 if (current_line == linenum)
637 /* We have found the start of the line we seek. */
640 /* FIXME: We could skip the read-in-the-line code
641 below if we know that we already have the whole
642 line in the buffer. */
644 /* Advance pos2 to the newline character we have just located. */
645 pos2 += (ptr - buffer);
647 /* Skip the newline and, if present, the carriage return. */
648 if (ptr + 1 == buffer + size)
651 if (fgetc (last_open_file) == '\r')
655 pos2 += (ptr[1] == '\r' ? 2 : 1);
657 /* Move the file pointer to this location. */
658 fseek (last_open_file, pos2, SEEK_SET);
665 /* Read in the line. */
666 c = fgetc (last_open_file);
668 while (c != EOF && c != '\n' && c != '\r')
674 c = fgetc (last_open_file);
677 /* If '\r' is followed by '\n', swallow that. Likewise, if '\n'
678 is followed by '\r', swallow that as well. */
679 if (c == '\r' || c == '\n')
681 int next = fgetc (last_open_file);
683 if ((c == '\r' && next != '\n')
684 || (c == '\n' && next != '\r'))
685 ungetc (next, last_open_file);
688 /* Terminate the line. */
691 /* Reset the file position. */
692 fseek (last_open_file, pos, SEEK_SET);
695 static const char *fn;
696 static unsigned int eject; /* Eject pending. */
697 static unsigned int page; /* Current page number. */
698 static const char *title; /* Current title. */
699 static const char *subtitle; /* Current subtitle. */
700 static unsigned int on_page; /* Number of lines printed on current page. */
703 listing_page (list_info_type *list)
705 /* Grope around, see if we can see a title or subtitle edict coming up
706 soon. (we look down 10 lines of the page and see if it's there) */
707 if ((eject || (on_page >= (unsigned int) paper_height))
708 && paper_height != 0)
712 int had_subtitle = 0;
716 while (c != 0 && list)
718 if (list->edict == EDICT_SBTTL && !had_subtitle)
721 subtitle = list->edict_arg;
723 if (list->edict == EDICT_TITLE && !had_title)
726 title = list->edict_arg;
734 fprintf (list_file, "\f");
737 fprintf (list_file, "%s %s \t\t\tpage %d\n", LISTING_HEADER, fn, page);
738 fprintf (list_file, "%s\n", title);
739 fprintf (list_file, "%s\n", subtitle);
745 /* Print a line into the list_file. Update the line count
746 and if necessary start a new page. */
749 emit_line (list_info_type * list, const char * format, ...)
753 va_start (args, format);
755 vfprintf (list_file, format, args);
763 calc_hex (list_info_type *list)
765 int data_buffer_size;
766 list_info_type *first = list;
767 unsigned int address = ~(unsigned int) 0;
770 unsigned int octet_in_frag;
772 /* Find first frag which says it belongs to this line. */
774 while (frag && frag->line != list)
775 frag = frag->fr_next;
779 data_buffer_size = 0;
781 /* Dump all the frags which belong to this line. */
782 while (frag_ptr != (fragS *) NULL && frag_ptr->line == first)
784 /* Print as many bytes from the fixed part as is sensible. */
786 while ((offsetT) octet_in_frag < frag_ptr->fr_fix
787 && data_buffer_size < MAX_BYTES - 3)
789 if (address == ~(unsigned int) 0)
790 address = frag_ptr->fr_address / OCTETS_PER_BYTE;
792 sprintf (data_buffer + data_buffer_size,
794 (frag_ptr->fr_literal[octet_in_frag]) & 0xff);
795 data_buffer_size += 2;
798 if (frag_ptr->fr_type == rs_fill)
800 unsigned int var_rep_max = octet_in_frag;
801 unsigned int var_rep_idx = octet_in_frag;
803 /* Print as many bytes from the variable part as is sensible. */
804 while (((offsetT) octet_in_frag
805 < (frag_ptr->fr_fix + frag_ptr->fr_var * frag_ptr->fr_offset))
806 && data_buffer_size < MAX_BYTES - 3)
808 if (address == ~(unsigned int) 0)
809 address = frag_ptr->fr_address / OCTETS_PER_BYTE;
811 sprintf (data_buffer + data_buffer_size,
813 (frag_ptr->fr_literal[var_rep_idx]) & 0xff);
814 data_buffer_size += 2;
819 if ((offsetT) var_rep_idx >= frag_ptr->fr_fix + frag_ptr->fr_var)
820 var_rep_idx = var_rep_max;
824 frag_ptr = frag_ptr->fr_next;
826 data_buffer[data_buffer_size] = '\0';
831 print_lines (list_info_type *list, unsigned int lineno,
832 const char *string, unsigned int address)
837 unsigned int octet_in_word = 0;
838 char *src = data_buffer;
840 struct list_message *msg;
842 /* Print the stuff on the first line. */
844 nchars = (LISTING_WORD_SIZE * 2 + 1) * listing_lhs_width;
846 /* Print the hex for the first line. */
847 if (address == ~(unsigned int) 0)
849 fprintf (list_file, "% 4d ", lineno);
850 for (idx = 0; idx < nchars; idx++)
851 fprintf (list_file, " ");
853 emit_line (NULL, "\t%s\n", string ? string : "");
858 fprintf (list_file, "% 4d ???? ", lineno);
860 fprintf (list_file, "% 4d %04x ", lineno, address);
862 /* And the data to go along with it. */
865 while (src[cur] && idx < nchars)
869 fprintf (list_file, "%c%c", src[offset], src[offset + 1]);
873 if (octet_in_word == LISTING_WORD_SIZE)
875 fprintf (list_file, " ");
883 for (; idx < nchars; idx++)
884 fprintf (list_file, " ");
886 emit_line (list, "\t%s\n", string ? string : "");
888 for (msg = list->messages; msg; msg = msg->next)
889 emit_line (list, "**** %s\n", msg->message);
892 lines < (unsigned int) listing_lhs_cont_lines
896 nchars = ((LISTING_WORD_SIZE * 2) + 1) * listing_lhs_width_second - 1;
899 /* Print any more lines of data, but more compactly. */
900 fprintf (list_file, "% 4d ", lineno);
902 while (src[cur] && idx < nchars)
906 fprintf (list_file, "%c%c", src[offset], src[offset + 1]);
911 if (octet_in_word == LISTING_WORD_SIZE)
913 fprintf (list_file, " ");
919 emit_line (list, "\n");
924 list_symbol_table (void)
926 extern symbolS *symbol_rootP;
933 for (ptr = symbol_rootP; ptr != (symbolS *) NULL; ptr = symbol_next (ptr))
935 if (SEG_NORMAL (S_GET_SEGMENT (ptr))
936 || S_GET_SEGMENT (ptr) == absolute_section)
938 /* Don't report section symbols. They are not interesting. */
939 if (symbol_section_p (ptr))
942 if (S_GET_NAME (ptr))
944 char buf[30], fmt[8];
945 valueT val = S_GET_VALUE (ptr);
947 /* @@ Note that this is dependent on the compilation options,
948 not solely on the target characteristics. */
949 if (sizeof (val) == 4 && sizeof (int) == 4)
950 sprintf (buf, "%08lx", (unsigned long) val);
951 else if (sizeof (val) <= sizeof (unsigned long))
953 sprintf (fmt, "%%0%lulx",
954 (unsigned long) (sizeof (val) * 2));
955 sprintf (buf, fmt, (unsigned long) val);
958 else if (sizeof (val) > 4)
959 sprintf_vma (buf, val);
966 fprintf (list_file, "DEFINED SYMBOLS\n");
971 if (symbol_get_frag (ptr) && symbol_get_frag (ptr)->line)
973 fprintf (list_file, "%20s:%-5d %s:%s %s\n",
974 symbol_get_frag (ptr)->line->file->filename,
975 symbol_get_frag (ptr)->line->line,
976 segment_name (S_GET_SEGMENT (ptr)),
977 buf, S_GET_NAME (ptr));
981 fprintf (list_file, "%33s:%s %s\n",
982 segment_name (S_GET_SEGMENT (ptr)),
983 buf, S_GET_NAME (ptr));
994 fprintf (list_file, "NO DEFINED SYMBOLS\n");
997 emit_line (NULL, "\n");
1001 for (ptr = symbol_rootP; ptr != (symbolS *) NULL; ptr = symbol_next (ptr))
1003 if (S_GET_NAME (ptr) && strlen (S_GET_NAME (ptr)) != 0)
1005 if (S_GET_SEGMENT (ptr) == undefined_section)
1011 emit_line (NULL, "UNDEFINED SYMBOLS\n");
1014 emit_line (NULL, "%s\n", S_GET_NAME (ptr));
1020 emit_line (NULL, "NO UNDEFINED SYMBOLS\n");
1023 typedef struct cached_line
1025 file_info_type * file;
1027 char buffer [LISTING_RHS_WIDTH];
1031 print_source (file_info_type * current_file,
1032 list_info_type * list,
1035 #define NUM_CACHE_LINES 3
1036 static cached_line cached_lines[NUM_CACHE_LINES];
1037 static int next_free_line = 0;
1038 cached_line * cache = NULL;
1040 if (current_file->linenum > list->hll_line
1041 && list->hll_line > 0)
1043 /* This can happen with modern optimizing compilers. The source
1044 lines from the high level language input program are split up
1045 and interleaved, meaning the line number we want to display
1046 (list->hll_line) can have already been displayed. We have
1049 a. Do nothing, since we have already displayed the source
1050 line. This was the old behaviour.
1052 b. Display the particular line requested again, but only
1053 that line. This is the new behaviour.
1055 c. Display the particular line requested again and reset
1056 the current_file->line_num value so that we redisplay
1057 all the following lines as well the next time we
1058 encounter a larger line number. */
1061 /* Check the cache, maybe we already have the line saved. */
1062 for (i = 0; i < NUM_CACHE_LINES; i++)
1063 if (cached_lines[i].file == current_file
1064 && cached_lines[i].line == list->hll_line)
1066 cache = cached_lines + i;
1070 if (i == NUM_CACHE_LINES)
1072 cache = cached_lines + next_free_line;
1074 if (next_free_line == NUM_CACHE_LINES)
1077 cache->file = current_file;
1078 cache->line = list->hll_line;
1079 cache->buffer[0] = 0;
1080 rebuffer_line (current_file, cache->line, cache->buffer, width);
1083 emit_line (list, "%4u:%-13s **** %s\n",
1084 cache->line, cache->file->filename, cache->buffer);
1088 if (!current_file->at_end)
1090 int num_lines_shown = 0;
1092 while (current_file->linenum < list->hll_line
1093 && !current_file->at_end)
1097 cache = cached_lines + next_free_line;
1098 cache->file = current_file;
1099 cache->line = current_file->linenum + 1;
1100 cache->buffer[0] = 0;
1101 p = buffer_line (current_file, cache->buffer, width);
1103 /* Cache optimization: If printing a group of lines
1104 cache the first and last lines in the group. */
1105 if (num_lines_shown == 0)
1108 if (next_free_line == NUM_CACHE_LINES)
1112 emit_line (list, "%4u:%-13s **** %s\n",
1113 cache->line, cache->file->filename, p);
1119 /* Sometimes the user doesn't want to be bothered by the debugging
1120 records inserted by the compiler, see if the line is suspicious. */
1123 debugging_pseudo (list_info_type *list, const char *line)
1126 static int in_debug;
1130 if (list->debugging)
1138 was_debug = in_debug;
1142 while (ISSPACE (*line))
1148 /* The ELF compiler sometimes emits blank lines after switching
1149 out of a debugging section. If the next line drops us back
1150 into debugging information, then don't print the blank line.
1151 This is a hack for a particular compiler behaviour, not a
1155 && list->next != NULL
1156 && list->next->debugging)
1168 if (strncmp (line, "def", 3) == 0)
1170 if (strncmp (line, "val", 3) == 0)
1172 if (strncmp (line, "scl", 3) == 0)
1174 if (strncmp (line, "line", 4) == 0)
1176 if (strncmp (line, "endef", 5) == 0)
1178 if (strncmp (line, "ln", 2) == 0)
1180 if (strncmp (line, "type", 4) == 0)
1182 if (strncmp (line, "size", 4) == 0)
1184 if (strncmp (line, "dim", 3) == 0)
1186 if (strncmp (line, "tag", 3) == 0)
1188 if (strncmp (line, "stabs", 5) == 0)
1190 if (strncmp (line, "stabn", 5) == 0)
1197 listing_listing (char *name ATTRIBUTE_UNUSED)
1199 list_info_type *list = head;
1200 file_info_type *current_hll_file = (file_info_type *) NULL;
1203 int show_listing = 1;
1206 buffer = (char *) xmalloc (listing_rhs_width);
1207 data_buffer = (char *) xmalloc (MAX_BYTES);
1213 unsigned int list_line;
1215 width = listing_rhs_width > paper_width ? paper_width :
1218 list_line = list->line;
1219 switch (list->edict)
1222 /* Skip all lines up to the current. */
1228 case EDICT_NOLIST_NEXT:
1229 if (show_listing == 0)
1237 title = list->edict_arg;
1240 subtitle = list->edict_arg;
1246 if (show_listing <= 0)
1248 while (list->file->linenum < list_line
1249 && !list->file->at_end)
1250 p = buffer_line (list->file, buffer, width);
1253 if (list->edict == EDICT_LIST
1254 || (list->edict == EDICT_NOLIST_NEXT && show_listing == 0))
1256 /* Enable listing for the single line that caused the enable. */
1261 if (show_listing > 0)
1263 /* Scan down the list and print all the stuff which can be done
1264 with this line (or lines). */
1266 current_hll_file = list->hll_file;
1268 if (current_hll_file && list->hll_line && (listing & LISTING_HLL))
1269 print_source (current_hll_file, list, width);
1271 if (list->line_contents)
1273 if (!((listing & LISTING_NODEBUG)
1274 && debugging_pseudo (list, list->line_contents)))
1276 list->file->linenum == 0 ? list->line : list->file->linenum,
1277 list->line_contents, calc_hex (list));
1279 free (list->line_contents);
1280 list->line_contents = NULL;
1284 while (list->file->linenum < list_line
1285 && !list->file->at_end)
1287 unsigned int address;
1289 p = buffer_line (list->file, buffer, width);
1291 if (list->file->linenum < list_line)
1292 address = ~(unsigned int) 0;
1294 address = calc_hex (list);
1296 if (!((listing & LISTING_NODEBUG)
1297 && debugging_pseudo (list, p)))
1298 print_lines (list, list->file->linenum, p, address);
1302 if (list->edict == EDICT_EJECT)
1306 if (list->edict == EDICT_NOLIST_NEXT && show_listing == 1)
1317 /* Print time stamp in ISO format: yyyy-mm-ddThh:mm:ss.ss+/-zzzz. */
1320 print_timestamp (void)
1322 const time_t now = time (NULL);
1323 struct tm * timestamp;
1324 char stampstr[MAX_DATELEN];
1326 /* Any portable way to obtain subsecond values??? */
1327 timestamp = localtime (&now);
1328 strftime (stampstr, MAX_DATELEN, "%Y-%m-%dT%H:%M:%S.000%z", timestamp);
1329 fprintf (list_file, _("\n time stamp \t: %s\n\n"), stampstr);
1333 print_single_option (char * opt, int *pos)
1335 int opt_len = strlen (opt);
1337 if ((*pos + opt_len) < paper_width)
1339 fprintf (list_file, _("%s "), opt);
1340 *pos = *pos + opt_len;
1344 fprintf (list_file, _("\n\t%s "), opt);
1349 /* Print options passed to as. */
1352 print_options (char ** argv)
1354 const char *field_name = _("\n options passed\t: ");
1355 int pos = strlen (field_name);
1358 fputs (field_name, list_file);
1359 for (p = &argv[1]; *p != NULL; p++)
1363 if (strcmp (*p, "-o") == 0)
1369 if (strcmp (*p, "-v") == 0)
1372 print_single_option (*p, &pos);
1376 /* Print a first section with basic info like file names, as version,
1377 options passed, target, and timestamp.
1378 The format of this section is as follows:
1382 fieldname TAB ':' fieldcontents
1383 { TAB fieldcontents-cont } */
1386 listing_general_info (char ** argv)
1388 /* Print the stuff on the first line. */
1390 listing_page (NULL);
1393 _(" GNU assembler version %s (%s)\n\t using BFD version %s."),
1394 VERSION, TARGET_ALIAS, BFD_VERSION_STRING);
1395 print_options (argv);
1396 fprintf (list_file, _("\n input file \t: %s"), fn);
1397 fprintf (list_file, _("\n output file \t: %s"), out_file_name);
1398 fprintf (list_file, _("\n target \t: %s"), TARGET_CANONICAL);
1403 listing_print (char *name, char **argv)
1417 list_file = fopen (name, FOPEN_WT);
1418 if (list_file != NULL)
1422 as_warn (_("can't open %s: %s"), name, xstrerror (errno));
1428 if (listing & LISTING_NOFORM)
1431 if (listing & LISTING_GENERAL)
1432 listing_general_info (argv);
1434 if (listing & LISTING_LISTING)
1435 listing_listing (name);
1437 if (listing & LISTING_SYMBOLS)
1438 list_symbol_table ();
1442 if (fclose (list_file) == EOF)
1443 as_warn (_("can't close %s: %s"), name, xstrerror (errno));
1447 fclose (last_open_file);
1451 listing_file (const char *name)
1457 listing_eject (int ignore ATTRIBUTE_UNUSED)
1460 listing_tail->edict = EDICT_EJECT;
1463 /* Turn listing on or off. An argument of 0 means to turn off
1464 listing. An argument of 1 means to turn on listing. An argument
1465 of 2 means to turn off listing, but as of the next line; that is,
1466 the current line should be listed, but the next line should not. */
1469 listing_list (int on)
1476 if (listing_tail->edict == EDICT_LIST)
1477 listing_tail->edict = EDICT_NONE;
1479 listing_tail->edict = EDICT_NOLIST;
1482 if (listing_tail->edict == EDICT_NOLIST
1483 || listing_tail->edict == EDICT_NOLIST_NEXT)
1484 listing_tail->edict = EDICT_NONE;
1486 listing_tail->edict = EDICT_LIST;
1489 listing_tail->edict = EDICT_NOLIST_NEXT;
1498 listing_psize (int width_only)
1502 paper_height = get_absolute_expression ();
1504 if (paper_height < 0 || paper_height > 1000)
1507 as_warn (_("strange paper height, set to no form"));
1510 if (*input_line_pointer != ',')
1512 demand_empty_rest_of_line ();
1516 ++input_line_pointer;
1519 paper_width = get_absolute_expression ();
1521 demand_empty_rest_of_line ();
1525 listing_nopage (int ignore ATTRIBUTE_UNUSED)
1531 listing_title (int depth)
1536 unsigned int length;
1539 if (*input_line_pointer != '\"')
1544 ++input_line_pointer;
1547 start = input_line_pointer;
1549 while (*input_line_pointer)
1552 ? *input_line_pointer == '\"'
1553 : is_end_of_line[(unsigned char) *input_line_pointer])
1557 length = input_line_pointer - start;
1558 ttl = (char *) xmalloc (length + 1);
1559 memcpy (ttl, start, length);
1561 listing_tail->edict = depth ? EDICT_SBTTL : EDICT_TITLE;
1562 listing_tail->edict_arg = ttl;
1565 input_line_pointer++;
1566 demand_empty_rest_of_line ();
1569 else if (*input_line_pointer == '\n')
1571 as_bad (_("new line in title"));
1572 demand_empty_rest_of_line ();
1577 input_line_pointer++;
1583 listing_source_line (unsigned int line)
1588 listing_tail->hll_line = line;
1594 listing_source_file (const char *file)
1597 listing_tail->hll_file = file_info (file);
1602 /* Dummy functions for when compiled without listing enabled. */
1605 listing_list (int on)
1611 listing_eject (int ignore)
1617 listing_psize (int ignore)
1623 listing_nopage (int ignore)
1629 listing_title (int depth)
1635 listing_file (const char *name)
1640 listing_newline (char *name)
1645 listing_source_line (unsigned int n)
1650 listing_source_file (const char *n)