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 char *n = concat (name, message, (char *) NULL);
238 struct list_message *lm = XNEW (struct list_message);
242 if (listing_tail->last_message)
243 listing_tail->last_message->next = lm;
245 listing_tail->messages = lm;
246 listing_tail->last_message = lm;
251 listing_warning (const char *message)
253 listing_message (_("Warning: "), message);
257 listing_error (const char *message)
259 listing_message (_("Error: "), message);
262 static file_info_type *
263 file_info (const char *file_name)
265 /* Find an entry with this file name. */
266 file_info_type *p = file_info_head;
268 while (p != (file_info_type *) NULL)
270 if (filename_cmp (p->filename, file_name) == 0)
275 /* Make new entry. */
276 p = XNEW (file_info_type);
277 p->next = file_info_head;
279 p->filename = xstrdup (file_name);
290 frag_wane (frag_now);
295 listing_newline (char *ps)
299 static unsigned int last_line = 0xffff;
300 static const char *last_file = NULL;
301 list_info_type *new_i = NULL;
306 if (now_seg == absolute_section)
310 /* In ELF, anything in a section beginning with .debug or .line is
311 considered to be debugging information. This includes the
312 statement which switches us into the debugging section, which we
313 can only set after we are already in the debugging section. */
314 if ((listing & LISTING_NODEBUG) != 0
315 && listing_tail != NULL
316 && ! listing_tail->debugging)
320 segname = segment_name (now_seg);
321 if (strncmp (segname, ".debug", sizeof ".debug" - 1) == 0
322 || strncmp (segname, ".line", sizeof ".line" - 1) == 0)
323 listing_tail->debugging = 1;
327 file = as_where (&line);
330 if (line == last_line
331 && !(last_file && file && filename_cmp (file, last_file)))
334 new_i = XNEW (list_info_type);
336 /* Detect if we are reading from stdin by examining the file
337 name returned by as_where().
339 [FIXME: We rely upon the name in the strcmp below being the
340 same as the one used by input_scrub_new_file(), if that is
341 not true, then this code will fail].
343 If we are reading from stdin, then we need to save each input
344 line here (assuming of course that we actually have a line of
345 input to read), so that it can be displayed in the listing
346 that is produced at the end of the assembly. */
347 if (strcmp (file, _("{standard input}")) == 0
348 && input_line_pointer != NULL)
355 for (copy = input_line_pointer;
357 || is_end_of_line [(unsigned char) *copy] != 1);
362 else if (*copy == '\\')
364 else if (*copy == '"')
365 seen_quote = !seen_quote;
368 len = copy - input_line_pointer + 1;
370 copy = (char *) xmalloc (len);
374 char *src = input_line_pointer;
379 unsigned char c = *src++;
381 /* Omit control characters in the listing. */
389 new_i->line_contents = copy;
392 new_i->line_contents = NULL;
396 new_i = XNEW (list_info_type);
397 new_i->line_contents = ps;
406 listing_tail->next = new_i;
410 listing_tail = new_i;
412 new_i->frag = frag_now;
414 new_i->file = file_info (file);
415 new_i->next = (list_info_type *) NULL;
416 new_i->messages = NULL;
417 new_i->last_message = NULL;
418 new_i->edict = EDICT_NONE;
419 new_i->hll_file = (file_info_type *) NULL;
421 new_i->debugging = 0;
426 /* In ELF, anything in a section beginning with .debug or .line is
427 considered to be debugging information. */
428 if ((listing & LISTING_NODEBUG) != 0)
432 segname = segment_name (now_seg);
433 if (strncmp (segname, ".debug", sizeof ".debug" - 1) == 0
434 || strncmp (segname, ".line", sizeof ".line" - 1) == 0)
435 new_i->debugging = 1;
440 /* Attach all current frags to the previous line instead of the
441 current line. This is called by the MIPS backend when it discovers
442 that it needs to add some NOP instructions; the added NOP
443 instructions should go with the instruction that has the delay, not
444 with the new instruction. */
447 listing_prev_line (void)
452 if (head == (list_info_type *) NULL
453 || head == listing_tail)
458 for (l = head; l->next != listing_tail; l = l->next)
461 for (f = frchain_now->frch_root; f != (fragS *) NULL; f = f->fr_next)
462 if (f->line == listing_tail)
465 listing_tail->frag = frag_now;
469 /* This function returns the next source line from the file supplied,
470 truncated to size. It appends a fake line to the end of each input
471 file to make using the returned buffer simpler. */
474 buffer_line (file_info_type *file, char *line, unsigned int size)
476 unsigned int count = 0;
480 /* If we couldn't open the file, return an empty line. */
484 /* Check the cache and see if we last used this file. */
485 if (!last_open_file_info || file != last_open_file_info)
489 last_open_file_info->pos = ftell (last_open_file);
490 fclose (last_open_file);
493 /* Open the file in the binary mode so that ftell above can
494 return a reliable value that we can feed to fseek below. */
495 last_open_file_info = file;
496 last_open_file = fopen (file->filename, FOPEN_RB);
497 if (last_open_file == NULL)
503 /* Seek to where we were last time this file was open. */
505 fseek (last_open_file, file->pos, SEEK_SET);
508 /* Leave room for null. */
511 c = fgetc (last_open_file);
513 while (c != EOF && c != '\n' && c != '\r')
519 c = fgetc (last_open_file);
522 /* If '\r' is followed by '\n', swallow that. Likewise, if '\n'
523 is followed by '\r', swallow that as well. */
524 if (c == '\r' || c == '\n')
526 int next = fgetc (last_open_file);
528 if ((c == '\r' && next != '\n')
529 || (c == '\n' && next != '\r'))
530 ungetc (next, last_open_file);
536 if (count + 2 < size)
549 /* This function rewinds the requested file back to the line requested,
550 reads it in again into the buffer provided and then restores the file
551 back to its original location. */
554 rebuffer_line (file_info_type * file,
555 unsigned int linenum,
559 unsigned int count = 0;
560 unsigned int current_line;
565 bfd_boolean found = FALSE;
568 if (file == NULL || buffer == NULL || size <= 1 || file->linenum <= linenum)
571 /* Check the cache and see if we last used this file. */
572 if (last_open_file_info == NULL || file != last_open_file_info)
576 last_open_file_info->pos = ftell (last_open_file);
577 fclose (last_open_file);
580 /* Open the file in the binary mode so that ftell above can
581 return a reliable value that we can feed to fseek below. */
582 last_open_file_info = file;
583 last_open_file = fopen (file->filename, FOPEN_RB);
584 if (last_open_file == NULL)
590 /* Seek to where we were last time this file was open. */
592 fseek (last_open_file, file->pos, SEEK_SET);
595 /* Remember where we are in the current file. */
596 pos2 = pos = ftell (last_open_file);
599 current_line = file->linenum;
601 /* Leave room for the nul at the end of the buffer. */
605 /* Increment the current line count by one.
606 This is to allow for the fact that we are searching for the
607 start of a previous line, but we do this by detecting end-of-line
608 character(s) not start-of-line characters. */
611 while (pos2 > 0 && ! found)
615 /* Move backwards through the file, looking for earlier lines. */
616 pos2 = (long) size > pos2 ? 0 : pos2 - size;
617 fseek (last_open_file, pos2, SEEK_SET);
619 /* Our caller has kindly provided us with a buffer, so we use it. */
620 if (fread (buffer, 1, size, last_open_file) != size)
622 as_warn (_("unable to rebuffer file: %s\n"), file->filename);
626 for (ptr = buffer + size; ptr >= buffer; -- ptr)
632 if (current_line == linenum)
634 /* We have found the start of the line we seek. */
637 /* FIXME: We could skip the read-in-the-line code
638 below if we know that we already have the whole
639 line in the buffer. */
641 /* Advance pos2 to the newline character we have just located. */
642 pos2 += (ptr - buffer);
644 /* Skip the newline and, if present, the carriage return. */
645 if (ptr + 1 == buffer + size)
648 if (fgetc (last_open_file) == '\r')
652 pos2 += (ptr[1] == '\r' ? 2 : 1);
654 /* Move the file pointer to this location. */
655 fseek (last_open_file, pos2, SEEK_SET);
662 /* Read in the line. */
663 c = fgetc (last_open_file);
665 while (c != EOF && c != '\n' && c != '\r')
671 c = fgetc (last_open_file);
674 /* If '\r' is followed by '\n', swallow that. Likewise, if '\n'
675 is followed by '\r', swallow that as well. */
676 if (c == '\r' || c == '\n')
678 int next = fgetc (last_open_file);
680 if ((c == '\r' && next != '\n')
681 || (c == '\n' && next != '\r'))
682 ungetc (next, last_open_file);
685 /* Terminate the line. */
688 /* Reset the file position. */
689 fseek (last_open_file, pos, SEEK_SET);
692 static const char *fn;
693 static unsigned int eject; /* Eject pending. */
694 static unsigned int page; /* Current page number. */
695 static const char *title; /* Current title. */
696 static const char *subtitle; /* Current subtitle. */
697 static unsigned int on_page; /* Number of lines printed on current page. */
700 listing_page (list_info_type *list)
702 /* Grope around, see if we can see a title or subtitle edict coming up
703 soon. (we look down 10 lines of the page and see if it's there) */
704 if ((eject || (on_page >= (unsigned int) paper_height))
705 && paper_height != 0)
709 int had_subtitle = 0;
713 while (c != 0 && list)
715 if (list->edict == EDICT_SBTTL && !had_subtitle)
718 subtitle = list->edict_arg;
720 if (list->edict == EDICT_TITLE && !had_title)
723 title = list->edict_arg;
731 fprintf (list_file, "\f");
734 fprintf (list_file, "%s %s \t\t\tpage %d\n", LISTING_HEADER, fn, page);
735 fprintf (list_file, "%s\n", title);
736 fprintf (list_file, "%s\n", subtitle);
742 /* Print a line into the list_file. Update the line count
743 and if necessary start a new page. */
746 emit_line (list_info_type * list, const char * format, ...)
750 va_start (args, format);
752 vfprintf (list_file, format, args);
760 calc_hex (list_info_type *list)
762 int data_buffer_size;
763 list_info_type *first = list;
764 unsigned int address = ~(unsigned int) 0;
767 unsigned int octet_in_frag;
769 /* Find first frag which says it belongs to this line. */
771 while (frag && frag->line != list)
772 frag = frag->fr_next;
776 data_buffer_size = 0;
778 /* Dump all the frags which belong to this line. */
779 while (frag_ptr != (fragS *) NULL && frag_ptr->line == first)
781 /* Print as many bytes from the fixed part as is sensible. */
783 while ((offsetT) octet_in_frag < frag_ptr->fr_fix
784 && data_buffer_size < MAX_BYTES - 3)
786 if (address == ~(unsigned int) 0)
787 address = frag_ptr->fr_address / OCTETS_PER_BYTE;
789 sprintf (data_buffer + data_buffer_size,
791 (frag_ptr->fr_literal[octet_in_frag]) & 0xff);
792 data_buffer_size += 2;
795 if (frag_ptr->fr_type == rs_fill)
797 unsigned int var_rep_max = octet_in_frag;
798 unsigned int var_rep_idx = octet_in_frag;
800 /* Print as many bytes from the variable part as is sensible. */
801 while (((offsetT) octet_in_frag
802 < (frag_ptr->fr_fix + frag_ptr->fr_var * frag_ptr->fr_offset))
803 && data_buffer_size < MAX_BYTES - 3)
805 if (address == ~(unsigned int) 0)
806 address = frag_ptr->fr_address / OCTETS_PER_BYTE;
808 sprintf (data_buffer + data_buffer_size,
810 (frag_ptr->fr_literal[var_rep_idx]) & 0xff);
811 data_buffer_size += 2;
816 if ((offsetT) var_rep_idx >= frag_ptr->fr_fix + frag_ptr->fr_var)
817 var_rep_idx = var_rep_max;
821 frag_ptr = frag_ptr->fr_next;
823 data_buffer[data_buffer_size] = '\0';
828 print_lines (list_info_type *list, unsigned int lineno,
829 const char *string, unsigned int address)
834 unsigned int octet_in_word = 0;
835 char *src = data_buffer;
837 struct list_message *msg;
839 /* Print the stuff on the first line. */
841 nchars = (LISTING_WORD_SIZE * 2 + 1) * listing_lhs_width;
843 /* Print the hex for the first line. */
844 if (address == ~(unsigned int) 0)
846 fprintf (list_file, "% 4d ", lineno);
847 for (idx = 0; idx < nchars; idx++)
848 fprintf (list_file, " ");
850 emit_line (NULL, "\t%s\n", string ? string : "");
855 fprintf (list_file, "% 4d ???? ", lineno);
857 fprintf (list_file, "% 4d %04x ", lineno, address);
859 /* And the data to go along with it. */
862 while (src[cur] && idx < nchars)
866 fprintf (list_file, "%c%c", src[offset], src[offset + 1]);
870 if (octet_in_word == LISTING_WORD_SIZE)
872 fprintf (list_file, " ");
880 for (; idx < nchars; idx++)
881 fprintf (list_file, " ");
883 emit_line (list, "\t%s\n", string ? string : "");
885 for (msg = list->messages; msg; msg = msg->next)
886 emit_line (list, "**** %s\n", msg->message);
889 lines < (unsigned int) listing_lhs_cont_lines
893 nchars = ((LISTING_WORD_SIZE * 2) + 1) * listing_lhs_width_second - 1;
896 /* Print any more lines of data, but more compactly. */
897 fprintf (list_file, "% 4d ", lineno);
899 while (src[cur] && idx < nchars)
903 fprintf (list_file, "%c%c", src[offset], src[offset + 1]);
908 if (octet_in_word == LISTING_WORD_SIZE)
910 fprintf (list_file, " ");
916 emit_line (list, "\n");
921 list_symbol_table (void)
923 extern symbolS *symbol_rootP;
930 for (ptr = symbol_rootP; ptr != (symbolS *) NULL; ptr = symbol_next (ptr))
932 if (SEG_NORMAL (S_GET_SEGMENT (ptr))
933 || S_GET_SEGMENT (ptr) == absolute_section)
935 /* Don't report section symbols. They are not interesting. */
936 if (symbol_section_p (ptr))
939 if (S_GET_NAME (ptr))
941 char buf[30], fmt[8];
942 valueT val = S_GET_VALUE (ptr);
944 /* @@ Note that this is dependent on the compilation options,
945 not solely on the target characteristics. */
946 if (sizeof (val) == 4 && sizeof (int) == 4)
947 sprintf (buf, "%08lx", (unsigned long) val);
948 else if (sizeof (val) <= sizeof (unsigned long))
950 sprintf (fmt, "%%0%lulx",
951 (unsigned long) (sizeof (val) * 2));
952 sprintf (buf, fmt, (unsigned long) val);
955 else if (sizeof (val) > 4)
956 sprintf_vma (buf, val);
963 fprintf (list_file, "DEFINED SYMBOLS\n");
968 if (symbol_get_frag (ptr) && symbol_get_frag (ptr)->line)
970 fprintf (list_file, "%20s:%-5d %s:%s %s\n",
971 symbol_get_frag (ptr)->line->file->filename,
972 symbol_get_frag (ptr)->line->line,
973 segment_name (S_GET_SEGMENT (ptr)),
974 buf, S_GET_NAME (ptr));
978 fprintf (list_file, "%33s:%s %s\n",
979 segment_name (S_GET_SEGMENT (ptr)),
980 buf, S_GET_NAME (ptr));
991 fprintf (list_file, "NO DEFINED SYMBOLS\n");
994 emit_line (NULL, "\n");
998 for (ptr = symbol_rootP; ptr != (symbolS *) NULL; ptr = symbol_next (ptr))
1000 if (S_GET_NAME (ptr) && strlen (S_GET_NAME (ptr)) != 0)
1002 if (S_GET_SEGMENT (ptr) == undefined_section)
1008 emit_line (NULL, "UNDEFINED SYMBOLS\n");
1011 emit_line (NULL, "%s\n", S_GET_NAME (ptr));
1017 emit_line (NULL, "NO UNDEFINED SYMBOLS\n");
1020 typedef struct cached_line
1022 file_info_type * file;
1024 char buffer [LISTING_RHS_WIDTH];
1028 print_source (file_info_type * current_file,
1029 list_info_type * list,
1032 #define NUM_CACHE_LINES 3
1033 static cached_line cached_lines[NUM_CACHE_LINES];
1034 static int next_free_line = 0;
1035 cached_line * cache = NULL;
1037 if (current_file->linenum > list->hll_line
1038 && list->hll_line > 0)
1040 /* This can happen with modern optimizing compilers. The source
1041 lines from the high level language input program are split up
1042 and interleaved, meaning the line number we want to display
1043 (list->hll_line) can have already been displayed. We have
1046 a. Do nothing, since we have already displayed the source
1047 line. This was the old behaviour.
1049 b. Display the particular line requested again, but only
1050 that line. This is the new behaviour.
1052 c. Display the particular line requested again and reset
1053 the current_file->line_num value so that we redisplay
1054 all the following lines as well the next time we
1055 encounter a larger line number. */
1058 /* Check the cache, maybe we already have the line saved. */
1059 for (i = 0; i < NUM_CACHE_LINES; i++)
1060 if (cached_lines[i].file == current_file
1061 && cached_lines[i].line == list->hll_line)
1063 cache = cached_lines + i;
1067 if (i == NUM_CACHE_LINES)
1069 cache = cached_lines + next_free_line;
1071 if (next_free_line == NUM_CACHE_LINES)
1074 cache->file = current_file;
1075 cache->line = list->hll_line;
1076 cache->buffer[0] = 0;
1077 rebuffer_line (current_file, cache->line, cache->buffer, width);
1080 emit_line (list, "%4u:%-13s **** %s\n",
1081 cache->line, cache->file->filename, cache->buffer);
1085 if (!current_file->at_end)
1087 int num_lines_shown = 0;
1089 while (current_file->linenum < list->hll_line
1090 && !current_file->at_end)
1094 cache = cached_lines + next_free_line;
1095 cache->file = current_file;
1096 cache->line = current_file->linenum + 1;
1097 cache->buffer[0] = 0;
1098 p = buffer_line (current_file, cache->buffer, width);
1100 /* Cache optimization: If printing a group of lines
1101 cache the first and last lines in the group. */
1102 if (num_lines_shown == 0)
1105 if (next_free_line == NUM_CACHE_LINES)
1109 emit_line (list, "%4u:%-13s **** %s\n",
1110 cache->line, cache->file->filename, p);
1116 /* Sometimes the user doesn't want to be bothered by the debugging
1117 records inserted by the compiler, see if the line is suspicious. */
1120 debugging_pseudo (list_info_type *list, const char *line)
1123 static int in_debug;
1127 if (list->debugging)
1135 was_debug = in_debug;
1139 while (ISSPACE (*line))
1145 /* The ELF compiler sometimes emits blank lines after switching
1146 out of a debugging section. If the next line drops us back
1147 into debugging information, then don't print the blank line.
1148 This is a hack for a particular compiler behaviour, not a
1152 && list->next != NULL
1153 && list->next->debugging)
1165 if (strncmp (line, "def", 3) == 0)
1167 if (strncmp (line, "val", 3) == 0)
1169 if (strncmp (line, "scl", 3) == 0)
1171 if (strncmp (line, "line", 4) == 0)
1173 if (strncmp (line, "endef", 5) == 0)
1175 if (strncmp (line, "ln", 2) == 0)
1177 if (strncmp (line, "type", 4) == 0)
1179 if (strncmp (line, "size", 4) == 0)
1181 if (strncmp (line, "dim", 3) == 0)
1183 if (strncmp (line, "tag", 3) == 0)
1185 if (strncmp (line, "stabs", 5) == 0)
1187 if (strncmp (line, "stabn", 5) == 0)
1194 listing_listing (char *name ATTRIBUTE_UNUSED)
1196 list_info_type *list = head;
1197 file_info_type *current_hll_file = (file_info_type *) NULL;
1200 int show_listing = 1;
1203 buffer = (char *) xmalloc (listing_rhs_width);
1204 data_buffer = (char *) xmalloc (MAX_BYTES);
1210 unsigned int list_line;
1212 width = listing_rhs_width > paper_width ? paper_width :
1215 list_line = list->line;
1216 switch (list->edict)
1219 /* Skip all lines up to the current. */
1225 case EDICT_NOLIST_NEXT:
1226 if (show_listing == 0)
1234 title = list->edict_arg;
1237 subtitle = list->edict_arg;
1243 if (show_listing <= 0)
1245 while (list->file->linenum < list_line
1246 && !list->file->at_end)
1247 p = buffer_line (list->file, buffer, width);
1250 if (list->edict == EDICT_LIST
1251 || (list->edict == EDICT_NOLIST_NEXT && show_listing == 0))
1253 /* Enable listing for the single line that caused the enable. */
1258 if (show_listing > 0)
1260 /* Scan down the list and print all the stuff which can be done
1261 with this line (or lines). */
1263 current_hll_file = list->hll_file;
1265 if (current_hll_file && list->hll_line && (listing & LISTING_HLL))
1266 print_source (current_hll_file, list, width);
1268 if (list->line_contents)
1270 if (!((listing & LISTING_NODEBUG)
1271 && debugging_pseudo (list, list->line_contents)))
1273 list->file->linenum == 0 ? list->line : list->file->linenum,
1274 list->line_contents, calc_hex (list));
1276 free (list->line_contents);
1277 list->line_contents = NULL;
1281 while (list->file->linenum < list_line
1282 && !list->file->at_end)
1284 unsigned int address;
1286 p = buffer_line (list->file, buffer, width);
1288 if (list->file->linenum < list_line)
1289 address = ~(unsigned int) 0;
1291 address = calc_hex (list);
1293 if (!((listing & LISTING_NODEBUG)
1294 && debugging_pseudo (list, p)))
1295 print_lines (list, list->file->linenum, p, address);
1299 if (list->edict == EDICT_EJECT)
1303 if (list->edict == EDICT_NOLIST_NEXT && show_listing == 1)
1314 /* Print time stamp in ISO format: yyyy-mm-ddThh:mm:ss.ss+/-zzzz. */
1317 print_timestamp (void)
1319 const time_t now = time (NULL);
1320 struct tm * timestamp;
1321 char stampstr[MAX_DATELEN];
1323 /* Any portable way to obtain subsecond values??? */
1324 timestamp = localtime (&now);
1325 strftime (stampstr, MAX_DATELEN, "%Y-%m-%dT%H:%M:%S.000%z", timestamp);
1326 fprintf (list_file, _("\n time stamp \t: %s\n\n"), stampstr);
1330 print_single_option (char * opt, int *pos)
1332 int opt_len = strlen (opt);
1334 if ((*pos + opt_len) < paper_width)
1336 fprintf (list_file, _("%s "), opt);
1337 *pos = *pos + opt_len;
1341 fprintf (list_file, _("\n\t%s "), opt);
1346 /* Print options passed to as. */
1349 print_options (char ** argv)
1351 const char *field_name = _("\n options passed\t: ");
1352 int pos = strlen (field_name);
1355 fputs (field_name, list_file);
1356 for (p = &argv[1]; *p != NULL; p++)
1360 if (strcmp (*p, "-o") == 0)
1366 if (strcmp (*p, "-v") == 0)
1369 print_single_option (*p, &pos);
1373 /* Print a first section with basic info like file names, as version,
1374 options passed, target, and timestamp.
1375 The format of this section is as follows:
1379 fieldname TAB ':' fieldcontents
1380 { TAB fieldcontents-cont } */
1383 listing_general_info (char ** argv)
1385 /* Print the stuff on the first line. */
1387 listing_page (NULL);
1390 _(" GNU assembler version %s (%s)\n\t using BFD version %s."),
1391 VERSION, TARGET_ALIAS, BFD_VERSION_STRING);
1392 print_options (argv);
1393 fprintf (list_file, _("\n input file \t: %s"), fn);
1394 fprintf (list_file, _("\n output file \t: %s"), out_file_name);
1395 fprintf (list_file, _("\n target \t: %s"), TARGET_CANONICAL);
1400 listing_print (char *name, char **argv)
1414 list_file = fopen (name, FOPEN_WT);
1415 if (list_file != NULL)
1419 as_warn (_("can't open %s: %s"), name, xstrerror (errno));
1425 if (listing & LISTING_NOFORM)
1428 if (listing & LISTING_GENERAL)
1429 listing_general_info (argv);
1431 if (listing & LISTING_LISTING)
1432 listing_listing (name);
1434 if (listing & LISTING_SYMBOLS)
1435 list_symbol_table ();
1439 if (fclose (list_file) == EOF)
1440 as_warn (_("can't close %s: %s"), name, xstrerror (errno));
1444 fclose (last_open_file);
1448 listing_file (const char *name)
1454 listing_eject (int ignore ATTRIBUTE_UNUSED)
1457 listing_tail->edict = EDICT_EJECT;
1460 /* Turn listing on or off. An argument of 0 means to turn off
1461 listing. An argument of 1 means to turn on listing. An argument
1462 of 2 means to turn off listing, but as of the next line; that is,
1463 the current line should be listed, but the next line should not. */
1466 listing_list (int on)
1473 if (listing_tail->edict == EDICT_LIST)
1474 listing_tail->edict = EDICT_NONE;
1476 listing_tail->edict = EDICT_NOLIST;
1479 if (listing_tail->edict == EDICT_NOLIST
1480 || listing_tail->edict == EDICT_NOLIST_NEXT)
1481 listing_tail->edict = EDICT_NONE;
1483 listing_tail->edict = EDICT_LIST;
1486 listing_tail->edict = EDICT_NOLIST_NEXT;
1495 listing_psize (int width_only)
1499 paper_height = get_absolute_expression ();
1501 if (paper_height < 0 || paper_height > 1000)
1504 as_warn (_("strange paper height, set to no form"));
1507 if (*input_line_pointer != ',')
1509 demand_empty_rest_of_line ();
1513 ++input_line_pointer;
1516 paper_width = get_absolute_expression ();
1518 demand_empty_rest_of_line ();
1522 listing_nopage (int ignore ATTRIBUTE_UNUSED)
1528 listing_title (int depth)
1533 unsigned int length;
1536 if (*input_line_pointer != '\"')
1541 ++input_line_pointer;
1544 start = input_line_pointer;
1546 while (*input_line_pointer)
1549 ? *input_line_pointer == '\"'
1550 : is_end_of_line[(unsigned char) *input_line_pointer])
1554 length = input_line_pointer - start;
1555 ttl = xmemdup0 (start, length);
1556 listing_tail->edict = depth ? EDICT_SBTTL : EDICT_TITLE;
1557 listing_tail->edict_arg = ttl;
1560 input_line_pointer++;
1561 demand_empty_rest_of_line ();
1564 else if (*input_line_pointer == '\n')
1566 as_bad (_("new line in title"));
1567 demand_empty_rest_of_line ();
1572 input_line_pointer++;
1578 listing_source_line (unsigned int line)
1583 listing_tail->hll_line = line;
1589 listing_source_file (const char *file)
1592 listing_tail->hll_file = file_info (file);
1597 /* Dummy functions for when compiled without listing enabled. */
1600 listing_list (int on)
1606 listing_eject (int ignore)
1612 listing_psize (int ignore)
1618 listing_nopage (int ignore)
1624 listing_title (int depth)
1630 listing_file (const char *name)
1635 listing_newline (char *name)
1640 listing_source_line (unsigned int n)
1645 listing_source_file (const char *n)