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)
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
23 /* Contributed by Steve Chamberlain <sac@cygnus.com>
25 A listing page looks like:
27 LISTING_HEADER sourcefilename pagenumber
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:
38 Put "stuff" onto the title line
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
48 Increment the enable listing counter
50 Decrement the enable listing counter
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
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
94 #include "safe-ctype.h"
95 #include "input-file.h"
103 #ifndef LISTING_HEADER
104 #define LISTING_HEADER "GAS LISTING"
106 #ifndef LISTING_WORD_SIZE
107 #define LISTING_WORD_SIZE 4
109 #ifndef LISTING_LHS_WIDTH
110 #define LISTING_LHS_WIDTH ((LISTING_WORD_SIZE) > 4 ? 1 : 4 / (LISTING_WORD_SIZE))
112 #ifndef LISTING_LHS_WIDTH_SECOND
113 #define LISTING_LHS_WIDTH_SECOND LISTING_LHS_WIDTH
115 #ifndef LISTING_RHS_WIDTH
116 #define LISTING_RHS_WIDTH 100
118 #ifndef LISTING_LHS_CONT_LINES
119 #define LISTING_LHS_CONT_LINES 4
121 #define MAX_DATELEN 30
123 /* This structure remembers which .s were used. */
124 typedef struct file_info_struct
126 struct file_info_struct * next;
129 unsigned int linenum;
133 /* This structure remembers which line from which file goes into which
135 struct list_info_struct
137 /* Frag which this line of source is nearest to. */
140 /* The actual line in the source file. */
143 /* Pointer to the file info struct for the file which this line
145 file_info_type *file;
147 /* The expanded text of any macro that may have been executing. */
151 struct list_info_struct *next;
153 /* Pointer to the file info struct for the high level language
154 source line that belongs here. */
155 file_info_type *hll_file;
157 /* High level language source line. */
158 unsigned int hll_line;
160 /* Pointer to any error message associated with this line. */
175 /* Nonzero if this line is to be omitted because it contains
176 debugging information. This can become a flags field if we come
177 up with more information to store here. */
181 typedef struct list_info_struct list_info_type;
183 int listing_lhs_width = LISTING_LHS_WIDTH;
184 int listing_lhs_width_second = LISTING_LHS_WIDTH_SECOND;
185 int listing_lhs_cont_lines = LISTING_LHS_CONT_LINES;
186 int listing_rhs_width = LISTING_RHS_WIDTH;
188 struct list_info_struct * listing_tail;
190 static file_info_type * file_info_head;
191 static file_info_type * last_open_file_info;
192 static FILE * last_open_file;
193 static struct list_info_struct * head;
194 static int paper_width = 200;
195 static int paper_height = 60;
199 /* File to output listings to. */
200 static FILE *list_file;
202 /* This static array is used to keep the text of data to be printed
203 before the start of the line. */
206 (((LISTING_WORD_SIZE * 2) + 1) * listing_lhs_width \
207 + ((((LISTING_WORD_SIZE * 2) + 1) * listing_lhs_width_second) \
208 * listing_lhs_cont_lines) \
211 static char *data_buffer;
214 static void listing_message (const char *, const char *);
215 static file_info_type *file_info (const char *);
216 static void new_frag (void);
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 int debugging_pseudo (list_info_type *, const char *);
222 static void listing_listing (char *);
225 listing_message (const char *name, const char *message)
227 if (listing_tail != (list_info_type *) NULL)
229 unsigned int l = strlen (name) + strlen (message) + 1;
230 char *n = (char *) xmalloc (l);
233 listing_tail->message = n;
238 listing_warning (const char *message)
240 listing_message (_("Warning:"), message);
244 listing_error (const char *message)
246 listing_message (_("Error:"), message);
249 static file_info_type *
250 file_info (const char *file_name)
252 /* Find an entry with this file name. */
253 file_info_type *p = file_info_head;
255 while (p != (file_info_type *) NULL)
257 if (strcmp (p->filename, file_name) == 0)
262 /* Make new entry. */
263 p = xmalloc (sizeof (file_info_type));
264 p->next = file_info_head;
266 p->filename = xstrdup (file_name);
277 frag_wane (frag_now);
282 listing_newline (char *ps)
286 static unsigned int last_line = 0xffff;
287 static char *last_file = NULL;
288 list_info_type *new_i = NULL;
293 if (now_seg == absolute_section)
297 /* In ELF, anything in a section beginning with .debug or .line is
298 considered to be debugging information. This includes the
299 statement which switches us into the debugging section, which we
300 can only set after we are already in the debugging section. */
301 if ((listing & LISTING_NODEBUG) != 0
302 && listing_tail != NULL
303 && ! listing_tail->debugging)
307 segname = segment_name (now_seg);
308 if (strncmp (segname, ".debug", sizeof ".debug" - 1) == 0
309 || strncmp (segname, ".line", sizeof ".line" - 1) == 0)
310 listing_tail->debugging = 1;
314 as_where (&file, &line);
317 if (line == last_line
318 && !(last_file && file && strcmp (file, last_file)))
321 new_i = (list_info_type *) xmalloc (sizeof (list_info_type));
323 /* Detect if we are reading from stdin by examining the file
324 name returned by as_where().
326 [FIXME: We rely upon the name in the strcmp below being the
327 same as the one used by input_scrub_new_file(), if that is
328 not true, then this code will fail].
330 If we are reading from stdin, then we need to save each input
331 line here (assuming of course that we actually have a line of
332 input to read), so that it can be displayed in the listing
333 that is produced at the end of the assembly. */
334 if (strcmp (file, _("{standard input}")) == 0
335 && input_line_pointer != NULL)
342 for (copy = input_line_pointer - 1;
344 || is_end_of_line [(unsigned char) *copy] != 1);
348 seen_slash = ! seen_slash;
349 else if (*copy == '"' && seen_slash)
350 seen_quote = ! seen_quote;
353 len = (copy - input_line_pointer) + 2;
355 copy = xmalloc (len);
359 char *src = input_line_pointer - 1;
364 unsigned char c = *src++;
366 /* Omit control characters in the listing. */
374 new_i->line_contents = copy;
377 new_i->line_contents = NULL;
381 new_i = (list_info_type *) xmalloc (sizeof (list_info_type));
382 new_i->line_contents = ps;
391 listing_tail->next = new_i;
395 listing_tail = new_i;
397 new_i->frag = frag_now;
399 new_i->file = file_info (file);
400 new_i->next = (list_info_type *) NULL;
401 new_i->message = (char *) NULL;
402 new_i->edict = EDICT_NONE;
403 new_i->hll_file = (file_info_type *) NULL;
405 new_i->debugging = 0;
410 /* In ELF, anything in a section beginning with .debug or .line is
411 considered to be debugging information. */
412 if ((listing & LISTING_NODEBUG) != 0)
416 segname = segment_name (now_seg);
417 if (strncmp (segname, ".debug", sizeof ".debug" - 1) == 0
418 || strncmp (segname, ".line", sizeof ".line" - 1) == 0)
419 new_i->debugging = 1;
424 /* Attach all current frags to the previous line instead of the
425 current line. This is called by the MIPS backend when it discovers
426 that it needs to add some NOP instructions; the added NOP
427 instructions should go with the instruction that has the delay, not
428 with the new instruction. */
431 listing_prev_line (void)
436 if (head == (list_info_type *) NULL
437 || head == listing_tail)
442 for (l = head; l->next != listing_tail; l = l->next)
445 for (f = frchain_now->frch_root; f != (fragS *) NULL; f = f->fr_next)
446 if (f->line == listing_tail)
449 listing_tail->frag = frag_now;
453 /* This function returns the next source line from the file supplied,
454 truncated to size. It appends a fake line to the end of each input
455 file to make using the returned buffer simpler. */
458 buffer_line (file_info_type *file, char *line, unsigned int size)
460 unsigned int count = 0;
464 /* If we couldn't open the file, return an empty line. */
468 /* Check the cache and see if we last used this file. */
469 if (!last_open_file_info || file != last_open_file_info)
473 last_open_file_info->pos = ftell (last_open_file);
474 fclose (last_open_file);
477 /* Open the file in the binary mode so that ftell above can
478 return a reliable value that we can feed to fseek below. */
479 last_open_file_info = file;
480 last_open_file = fopen (file->filename, FOPEN_RB);
481 if (last_open_file == NULL)
487 /* Seek to where we were last time this file was open. */
489 fseek (last_open_file, file->pos, SEEK_SET);
492 /* Leave room for null. */
495 c = fgetc (last_open_file);
497 while (c != EOF && c != '\n' && c != '\r')
503 c = fgetc (last_open_file);
506 /* If '\r' is followed by '\n', swallow that. Likewise, if '\n'
507 is followed by '\r', swallow that as well. */
508 if (c == '\r' || c == '\n')
510 int next = fgetc (last_open_file);
512 if ((c == '\r' && next != '\n')
513 || (c == '\n' && next != '\r'))
514 ungetc (next, last_open_file);
520 if (count + 2 < size)
533 /* This function rewinds the requested file back to the line requested,
534 reads it in again into the buffer provided and then restores the file
535 back to its original location. */
538 rebuffer_line (file_info_type * file,
539 unsigned int linenum,
543 unsigned int count = 0;
544 unsigned int current_line = 1;
550 if (file == NULL || buffer == NULL || size == 0 || file->linenum <= linenum)
553 /* Check the cache and see if we last used this file. */
554 if (last_open_file_info == NULL || file != last_open_file_info)
558 last_open_file_info->pos = ftell (last_open_file);
559 fclose (last_open_file);
562 /* Open the file in the binary mode so that ftell above can
563 return a reliable value that we can feed to fseek below. */
564 last_open_file_info = file;
565 last_open_file = fopen (file->filename, FOPEN_RB);
566 if (last_open_file == NULL)
572 /* Seek to where we were last time this file was open. */
574 fseek (last_open_file, file->pos, SEEK_SET);
577 /* Remember where we are in the current file. */
578 pos = ftell (last_open_file);
580 /* Go back to the beginning. */
581 fseek (last_open_file, 0, SEEK_SET);
583 /* Skip lines prior to the one we are interested in. */
584 while (current_line < linenum)
586 /* fgets only stops on newlines and has a size limit,
587 so we read one character at a time instead. */
590 c = fgetc (last_open_file);
592 while (c != EOF && c != '\n' && c != '\r');
596 if (c == '\r' || c == '\n')
598 int next = fgetc (last_open_file);
600 /* If '\r' is followed by '\n', swallow that. Likewise, if '\n'
601 is followed by '\r', swallow that as well. */
602 if ((c == '\r' && next != '\n')
603 || (c == '\n' && next != '\r'))
604 ungetc (next, last_open_file);
608 /* Leave room for the nul at the end of the buffer. */
611 /* Read in the line. */
612 c = fgetc (last_open_file);
614 while (c != EOF && c != '\n' && c != '\r')
620 c = fgetc (last_open_file);
623 /* If '\r' is followed by '\n', swallow that. Likewise, if '\n'
624 is followed by '\r', swallow that as well. */
625 if (c == '\r' || c == '\n')
627 int next = fgetc (last_open_file);
629 if ((c == '\r' && next != '\n')
630 || (c == '\n' && next != '\r'))
631 ungetc (next, last_open_file);
634 /* Terminate the line. */
637 /* Reset the file position. */
638 fseek (last_open_file, pos, SEEK_SET);
643 static const char *fn;
645 static unsigned int eject; /* Eject pending */
646 static unsigned int page; /* Current page number */
647 static char *title; /* Current title */
648 static char *subtitle; /* Current subtitle */
649 static unsigned int on_page; /* Number of lines printed on current page */
652 listing_page (list_info_type *list)
654 /* Grope around, see if we can see a title or subtitle edict coming up
655 soon. (we look down 10 lines of the page and see if it's there) */
656 if ((eject || (on_page >= (unsigned int) paper_height))
657 && paper_height != 0)
661 int had_subtitle = 0;
665 while (c != 0 && list)
667 if (list->edict == EDICT_SBTTL && !had_subtitle)
670 subtitle = list->edict_arg;
672 if (list->edict == EDICT_TITLE && !had_title)
675 title = list->edict_arg;
683 fprintf (list_file, "\f");
686 fprintf (list_file, "%s %s \t\t\tpage %d\n", LISTING_HEADER, fn, page);
687 fprintf (list_file, "%s\n", title);
688 fprintf (list_file, "%s\n", subtitle);
694 /* Print a line into the list_file. Update the line count
695 and if necessary start a new page. */
698 emit_line (list_info_type * list, const char * format, ...)
702 va_start (args, format);
704 vfprintf (list_file, format, args);
712 calc_hex (list_info_type *list)
714 int data_buffer_size;
715 list_info_type *first = list;
716 unsigned int address = ~(unsigned int) 0;
719 unsigned int octet_in_frag;
721 /* Find first frag which says it belongs to this line. */
723 while (frag && frag->line != list)
724 frag = frag->fr_next;
728 data_buffer_size = 0;
730 /* Dump all the frags which belong to this line. */
731 while (frag_ptr != (fragS *) NULL && frag_ptr->line == first)
733 /* Print as many bytes from the fixed part as is sensible. */
735 while ((offsetT) octet_in_frag < frag_ptr->fr_fix
736 && data_buffer_size < MAX_BYTES - 3)
738 if (address == ~(unsigned int) 0)
739 address = frag_ptr->fr_address / OCTETS_PER_BYTE;
741 sprintf (data_buffer + data_buffer_size,
743 (frag_ptr->fr_literal[octet_in_frag]) & 0xff);
744 data_buffer_size += 2;
747 if (frag_ptr->fr_type == rs_fill)
749 unsigned int var_rep_max = octet_in_frag;
750 unsigned int var_rep_idx = octet_in_frag;
752 /* Print as many bytes from the variable part as is sensible. */
753 while (((offsetT) octet_in_frag
754 < (frag_ptr->fr_fix + frag_ptr->fr_var * frag_ptr->fr_offset))
755 && data_buffer_size < MAX_BYTES - 3)
757 if (address == ~(unsigned int) 0)
758 address = frag_ptr->fr_address / OCTETS_PER_BYTE;
760 sprintf (data_buffer + data_buffer_size,
762 (frag_ptr->fr_literal[var_rep_idx]) & 0xff);
763 data_buffer_size += 2;
768 if ((offsetT) var_rep_idx >= frag_ptr->fr_fix + frag_ptr->fr_var)
769 var_rep_idx = var_rep_max;
773 frag_ptr = frag_ptr->fr_next;
775 data_buffer[data_buffer_size] = '\0';
780 print_lines (list_info_type *list, unsigned int lineno,
781 char *string, unsigned int address)
786 unsigned int octet_in_word = 0;
787 char *src = data_buffer;
790 /* Print the stuff on the first line. */
792 nchars = (LISTING_WORD_SIZE * 2 + 1) * listing_lhs_width;
794 /* Print the hex for the first line. */
795 if (address == ~(unsigned int) 0)
797 fprintf (list_file, "% 4d ", lineno);
798 for (idx = 0; idx < nchars; idx++)
799 fprintf (list_file, " ");
801 emit_line (NULL, "\t%s\n", string ? string : "");
806 fprintf (list_file, "% 4d ???? ", lineno);
808 fprintf (list_file, "% 4d %04x ", lineno, address);
810 /* And the data to go along with it. */
813 while (src[cur] && idx < nchars)
817 fprintf (list_file, "%c%c", src[offset], src[offset + 1]);
821 if (octet_in_word == LISTING_WORD_SIZE)
823 fprintf (list_file, " ");
831 for (; idx < nchars; idx++)
832 fprintf (list_file, " ");
834 emit_line (list, "\t%s\n", string ? string : "");
837 emit_line (list, "**** %s\n", list->message);
840 lines < (unsigned int) listing_lhs_cont_lines
844 nchars = ((LISTING_WORD_SIZE * 2) + 1) * listing_lhs_width_second - 1;
847 /* Print any more lines of data, but more compactly. */
848 fprintf (list_file, "% 4d ", lineno);
850 while (src[cur] && idx < nchars)
854 fprintf (list_file, "%c%c", src[offset], src[offset + 1]);
859 if (octet_in_word == LISTING_WORD_SIZE)
861 fprintf (list_file, " ");
867 emit_line (list, "\n");
872 list_symbol_table (void)
874 extern symbolS *symbol_rootP;
881 for (ptr = symbol_rootP; ptr != (symbolS *) NULL; ptr = symbol_next (ptr))
883 if (SEG_NORMAL (S_GET_SEGMENT (ptr))
884 || S_GET_SEGMENT (ptr) == absolute_section)
886 /* Don't report section symbols. They are not interesting. */
887 if (symbol_section_p (ptr))
890 if (S_GET_NAME (ptr))
892 char buf[30], fmt[8];
893 valueT val = S_GET_VALUE (ptr);
895 /* @@ Note that this is dependent on the compilation options,
896 not solely on the target characteristics. */
897 if (sizeof (val) == 4 && sizeof (int) == 4)
898 sprintf (buf, "%08lx", (unsigned long) val);
899 else if (sizeof (val) <= sizeof (unsigned long))
901 sprintf (fmt, "%%0%lulx",
902 (unsigned long) (sizeof (val) * 2));
903 sprintf (buf, fmt, (unsigned long) val);
906 else if (sizeof (val) > 4)
907 sprintf_vma (buf, val);
914 fprintf (list_file, "DEFINED SYMBOLS\n");
919 if (symbol_get_frag (ptr) && symbol_get_frag (ptr)->line)
921 fprintf (list_file, "%20s:%-5d %s:%s %s\n",
922 symbol_get_frag (ptr)->line->file->filename,
923 symbol_get_frag (ptr)->line->line,
924 segment_name (S_GET_SEGMENT (ptr)),
925 buf, S_GET_NAME (ptr));
929 fprintf (list_file, "%33s:%s %s\n",
930 segment_name (S_GET_SEGMENT (ptr)),
931 buf, S_GET_NAME (ptr));
942 fprintf (list_file, "NO DEFINED SYMBOLS\n");
945 emit_line (NULL, "\n");
949 for (ptr = symbol_rootP; ptr != (symbolS *) NULL; ptr = symbol_next (ptr))
951 if (S_GET_NAME (ptr) && strlen (S_GET_NAME (ptr)) != 0)
953 if (S_GET_SEGMENT (ptr) == undefined_section)
959 emit_line (NULL, "UNDEFINED SYMBOLS\n");
962 emit_line (NULL, "%s\n", S_GET_NAME (ptr));
968 emit_line (NULL, "NO UNDEFINED SYMBOLS\n");
971 typedef struct cached_line
973 file_info_type * file;
975 char buffer [LISTING_RHS_WIDTH];
979 print_source (file_info_type * current_file,
980 list_info_type * list,
983 #define NUM_CACHE_LINES 3
984 static cached_line cached_lines[NUM_CACHE_LINES];
985 static int next_free_line = 0;
986 cached_line * cache = NULL;
988 if (current_file->linenum > list->hll_line
989 && list->hll_line > 0)
991 /* This can happen with modern optimizing compilers. The source
992 lines from the high level language input program are split up
993 and interleaved, meaning the line number we want to display
994 (list->hll_line) can have already been displayed. We have
997 a. Do nothing, since we have already displayed the source
998 line. This was the old behaviour.
1000 b. Display the particular line requested again, but only
1001 that line. This is the new behaviour.
1003 c. Display the particular line requested again and reset
1004 the current_file->line_num value so that we redisplay
1005 all the following lines as well the next time we
1006 encounter a larger line number. */
1009 /* Check the cache, maybe we already have the line saved. */
1010 for (i = 0; i < NUM_CACHE_LINES; i++)
1011 if (cached_lines[i].file == current_file
1012 && cached_lines[i].line == list->hll_line)
1014 cache = cached_lines + i;
1018 if (i == NUM_CACHE_LINES)
1020 cache = cached_lines + next_free_line;
1022 if (next_free_line == NUM_CACHE_LINES)
1025 cache->file = current_file;
1026 cache->line = list->hll_line;
1027 cache->buffer[0] = 0;
1028 rebuffer_line (current_file, cache->line, cache->buffer, width);
1031 emit_line (list, "%4u:%-13s **** %s\n",
1032 cache->line, cache->file->filename, cache->buffer);
1036 if (!current_file->at_end)
1038 int num_lines_shown = 0;
1040 while (current_file->linenum < list->hll_line
1041 && !current_file->at_end)
1043 cached_line * cache = cached_lines + next_free_line;
1046 cache->file = current_file;
1047 cache->line = current_file->linenum;
1048 cache->buffer[0] = 0;
1049 p = buffer_line (current_file, cache->buffer, width);
1051 /* Cache optimization: If printing a group of lines
1052 cache the first and last lines in the group. */
1053 if (num_lines_shown == 0)
1056 if (next_free_line == NUM_CACHE_LINES)
1060 emit_line (list, "%4u:%-13s **** %s\n",
1061 cache->line, cache->file->filename, p);
1067 /* Sometimes the user doesn't want to be bothered by the debugging
1068 records inserted by the compiler, see if the line is suspicious. */
1071 debugging_pseudo (list_info_type *list, const char *line)
1073 static int in_debug;
1076 if (list->debugging)
1082 was_debug = in_debug;
1085 while (ISSPACE (*line))
1091 /* The ELF compiler sometimes emits blank lines after switching
1092 out of a debugging section. If the next line drops us back
1093 into debugging information, then don't print the blank line.
1094 This is a hack for a particular compiler behaviour, not a
1098 && list->next != NULL
1099 && list->next->debugging)
1111 if (strncmp (line, "def", 3) == 0)
1113 if (strncmp (line, "val", 3) == 0)
1115 if (strncmp (line, "scl", 3) == 0)
1117 if (strncmp (line, "line", 4) == 0)
1119 if (strncmp (line, "endef", 5) == 0)
1121 if (strncmp (line, "ln", 2) == 0)
1123 if (strncmp (line, "type", 4) == 0)
1125 if (strncmp (line, "size", 4) == 0)
1127 if (strncmp (line, "dim", 3) == 0)
1129 if (strncmp (line, "tag", 3) == 0)
1131 if (strncmp (line, "stabs", 5) == 0)
1133 if (strncmp (line, "stabn", 5) == 0)
1140 listing_listing (char *name ATTRIBUTE_UNUSED)
1142 list_info_type *list = head;
1143 file_info_type *current_hll_file = (file_info_type *) NULL;
1147 int show_listing = 1;
1150 buffer = xmalloc (listing_rhs_width);
1151 data_buffer = xmalloc (MAX_BYTES);
1157 unsigned int list_line;
1159 width = listing_rhs_width > paper_width ? paper_width :
1162 list_line = list->line;
1163 switch (list->edict)
1166 /* Skip all lines up to the current. */
1172 case EDICT_NOLIST_NEXT:
1173 if (show_listing == 0)
1181 title = list->edict_arg;
1184 subtitle = list->edict_arg;
1190 if (show_listing <= 0)
1192 while (list->file->linenum < list_line
1193 && !list->file->at_end)
1194 p = buffer_line (list->file, buffer, width);
1197 if (list->edict == EDICT_LIST
1198 || (list->edict == EDICT_NOLIST_NEXT && show_listing == 0))
1200 /* Enable listing for the single line that caused the enable. */
1205 if (show_listing > 0)
1207 /* Scan down the list and print all the stuff which can be done
1208 with this line (or lines). */
1212 current_hll_file = list->hll_file;
1214 if (current_hll_file && list->hll_line && (listing & LISTING_HLL))
1215 print_source (current_hll_file, list, width);
1217 if (list->line_contents)
1219 if (!((listing & LISTING_NODEBUG)
1220 && debugging_pseudo (list, list->line_contents)))
1222 list->file->linenum == 0 ? list->line : list->file->linenum,
1223 list->line_contents, calc_hex (list));
1225 free (list->line_contents);
1226 list->line_contents = NULL;
1230 while (list->file->linenum < list_line
1231 && !list->file->at_end)
1233 unsigned int address;
1235 p = buffer_line (list->file, buffer, width);
1237 if (list->file->linenum < list_line)
1238 address = ~(unsigned int) 0;
1240 address = calc_hex (list);
1242 if (!((listing & LISTING_NODEBUG)
1243 && debugging_pseudo (list, p)))
1244 print_lines (list, list->file->linenum, p, address);
1248 if (list->edict == EDICT_EJECT)
1252 if (list->edict == EDICT_NOLIST_NEXT && show_listing == 1)
1263 /* Print time stamp in ISO format: yyyy-mm-ddThh:mm:ss.ss+/-zzzz. */
1266 print_timestamp (void)
1268 const time_t now = time (NULL);
1269 struct tm * timestamp;
1270 char stampstr[MAX_DATELEN];
1272 /* Any portable way to obtain subsecond values??? */
1273 timestamp = localtime (&now);
1274 strftime (stampstr, MAX_DATELEN, "%Y-%m-%dT%H:%M:%S.000%z", timestamp);
1275 fprintf (list_file, _("\n time stamp \t: %s\n\n"), stampstr);
1279 print_single_option (char * opt, int *pos)
1281 int opt_len = strlen (opt);
1283 if ((*pos + opt_len) < paper_width)
1285 fprintf (list_file, _("%s "), opt);
1286 *pos = *pos + opt_len;
1290 fprintf (list_file, _("\n\t%s "), opt);
1295 /* Print options passed to as. */
1298 print_options (char ** argv)
1300 const char *field_name = _("\n options passed\t: ");
1301 int pos = strlen (field_name);
1304 fputs (field_name, list_file);
1305 for (p = &argv[1]; *p != NULL; p++)
1309 if (strcmp (*p, "-o") == 0)
1315 if (strcmp (*p, "-v") == 0)
1318 print_single_option (*p, &pos);
1322 /* Print a first section with basic info like file names, as version,
1323 options passed, target, and timestamp.
1324 The format of this section is as follows:
1328 fieldname TAB ':' fieldcontents
1329 { TAB fieldcontents-cont } */
1332 listing_general_info (char ** argv)
1334 /* Print the stuff on the first line. */
1336 listing_page (NULL);
1339 _(" GNU assembler version %s (%s)\n\t using BFD version %s."),
1340 VERSION, TARGET_ALIAS, BFD_VERSION_STRING);
1341 print_options (argv);
1342 fprintf (list_file, _("\n input file \t: %s"), fn);
1343 fprintf (list_file, _("\n output file \t: %s"), out_file_name);
1344 fprintf (list_file, _("\n target \t: %s"), TARGET_CANONICAL);
1349 listing_print (char *name, char **argv)
1363 list_file = fopen (name, FOPEN_WT);
1364 if (list_file != NULL)
1368 as_warn (_("can't open %s: %s"), name, xstrerror (errno));
1374 if (listing & LISTING_NOFORM)
1377 if (listing & LISTING_GENERAL)
1378 listing_general_info (argv);
1380 if (listing & LISTING_LISTING)
1381 listing_listing (name);
1383 if (listing & LISTING_SYMBOLS)
1384 list_symbol_table ();
1388 if (fclose (list_file) == EOF)
1389 as_warn (_("can't close %s: %s"), name, xstrerror (errno));
1393 fclose (last_open_file);
1397 listing_file (const char *name)
1403 listing_eject (int ignore ATTRIBUTE_UNUSED)
1406 listing_tail->edict = EDICT_EJECT;
1410 listing_flags (int ignore ATTRIBUTE_UNUSED)
1412 while ((*input_line_pointer++) && (*input_line_pointer != '\n'))
1413 input_line_pointer++;
1417 /* Turn listing on or off. An argument of 0 means to turn off
1418 listing. An argument of 1 means to turn on listing. An argument
1419 of 2 means to turn off listing, but as of the next line; that is,
1420 the current line should be listed, but the next line should not. */
1423 listing_list (int on)
1430 if (listing_tail->edict == EDICT_LIST)
1431 listing_tail->edict = EDICT_NONE;
1433 listing_tail->edict = EDICT_NOLIST;
1436 if (listing_tail->edict == EDICT_NOLIST
1437 || listing_tail->edict == EDICT_NOLIST_NEXT)
1438 listing_tail->edict = EDICT_NONE;
1440 listing_tail->edict = EDICT_LIST;
1443 listing_tail->edict = EDICT_NOLIST_NEXT;
1452 listing_psize (int width_only)
1456 paper_height = get_absolute_expression ();
1458 if (paper_height < 0 || paper_height > 1000)
1461 as_warn (_("strange paper height, set to no form"));
1464 if (*input_line_pointer != ',')
1466 demand_empty_rest_of_line ();
1470 ++input_line_pointer;
1473 paper_width = get_absolute_expression ();
1475 demand_empty_rest_of_line ();
1479 listing_nopage (int ignore ATTRIBUTE_UNUSED)
1485 listing_title (int depth)
1490 unsigned int length;
1493 if (*input_line_pointer != '\"')
1498 ++input_line_pointer;
1501 start = input_line_pointer;
1503 while (*input_line_pointer)
1506 ? *input_line_pointer == '\"'
1507 : is_end_of_line[(unsigned char) *input_line_pointer])
1511 length = input_line_pointer - start;
1512 ttl = xmalloc (length + 1);
1513 memcpy (ttl, start, length);
1515 listing_tail->edict = depth ? EDICT_SBTTL : EDICT_TITLE;
1516 listing_tail->edict_arg = ttl;
1519 input_line_pointer++;
1520 demand_empty_rest_of_line ();
1523 else if (*input_line_pointer == '\n')
1525 as_bad (_("new line in title"));
1526 demand_empty_rest_of_line ();
1531 input_line_pointer++;
1537 listing_source_line (unsigned int line)
1542 listing_tail->hll_line = line;
1548 listing_source_file (const char *file)
1551 listing_tail->hll_file = file_info (file);
1556 /* Dummy functions for when compiled without listing enabled. */
1559 listing_flags (int ignore)
1565 listing_list (int on)
1571 listing_eject (int ignore)
1577 listing_psize (int ignore)
1583 listing_nopage (int ignore)
1589 listing_title (int depth)
1595 listing_file (const char *name)
1600 listing_newline (char *name)
1605 listing_source_line (unsigned int n)
1610 listing_source_file (const char *n)