1 /* listing.c - mainting assembly listings
2 Copyright (C) 1991, 1992 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 2, 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
18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
21 Contributed by Steve Chamberlain
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.
59 Listings are a maintained by read calling various listing_<foo>
60 functions. What happens most is that the macro NO_LISTING is not
61 defined (from the Makefile), then the macro LISTING_NEWLINE expands
62 into a call to listing_newline. The call is done from read.c, every
63 time it sees a newline, and -l is on the command line.
65 The function listing_newline remembers the frag associated with the
66 newline, and creates a new frag - note that this is wasteful, but not
67 a big deal, since listing slows things down a lot anyway. The
68 function also rememebers when the filename changes.
70 When all the input has finished, and gas has had a chance to settle
71 down, the listing is output. This is done by running down the list of
72 frag/source file records, and opening the files as needed and printing
73 out the bytes and chars associated with them.
75 The only things which the architecture can change about the listing
76 are defined in these macros:
78 LISTING_HEADER The name of the architecture
79 LISTING_WORD_SIZE The make of the number of bytes in a word, this determines
80 the clumping of the output data. eg a value of
81 2 makes words look like 1234 5678, whilst 1
82 would make the same value look like 12 34 56
84 LISTING_LHS_WIDTH Number of words of above size for the lhs
86 LISTING_LHS_WIDTH_SECOND Number of words for the data on the lhs
89 LISTING_LHS_CONT_LINES Max number of lines to use up for a continutation
90 LISTING_RHS_WIDTH Number of chars from the input file to print
98 #include "input-file.h"
102 #ifndef LISTING_HEADER
103 #define LISTING_HEADER "GAS LISTING"
105 #ifndef LISTING_WORD_SIZE
106 #define LISTING_WORD_SIZE 4
108 #ifndef LISTING_LHS_WIDTH
109 #define LISTING_LHS_WIDTH 1
111 #ifndef LISTING_LHS_WIDTH_SECOND
112 #define LISTING_LHS_WIDTH_SECOND 1
114 #ifndef LISTING_RHS_WIDTH
115 #define LISTING_RHS_WIDTH 100
117 #ifndef LISTING_LHS_CONT_LINES
118 #define LISTING_LHS_CONT_LINES 4
124 /* This structure remembers which .s were used */
125 typedef struct file_info_struct
130 struct file_info_struct *next;
137 /* this structure rememebrs which line from which file goes into which
139 typedef struct list_info_struct
141 /* Frag which this line of source is nearest to */
143 /* The actual line in the source file */
145 /* Pointer to the file info struct for the file which this line
147 file_info_type *file;
150 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 */
161 /* Pointer to any error message associated with this line */
180 static struct list_info_struct *head;
181 struct list_info_struct *listing_tail;
183 extern fragS *frag_now;
186 static int paper_width = 200;
187 static int paper_height = 60;
190 /* this static array is used to keep the text of data to be printed
191 before the start of the line.
192 It is stored so we can give a bit more info on the next line. To much, and large
193 initialized arrays will use up lots of paper.
196 static char data_buffer[100];
197 static unsigned int data_buffer_size;
201 static void listing_message PARAMS ((const char *name, const char *message));
202 static file_info_type *file_info PARAMS ((const char *file_name));
203 static void new_frag PARAMS ((void));
204 static char *buffer_line PARAMS ((file_info_type *file,
205 char *line, unsigned int size));
206 static void listing_page PARAMS ((list_info_type *list));
207 static unsigned int calc_hex PARAMS ((list_info_type *list));
208 static void print_lines PARAMS ((list_info_type *list,
210 unsigned int address));
211 static void list_symbol_table PARAMS ((void));
212 static void print_source PARAMS ((file_info_type *current_file,
213 list_info_type *list,
215 unsigned int width));
216 static int debugging_pseudo PARAMS ((char *line));
217 static void listing_listing PARAMS ((char *name));
221 listing_message (name, message)
225 unsigned int l = strlen (name) + strlen (message) + 1;
226 char *n = (char *) xmalloc (l);
229 if (listing_tail != (list_info_type *) NULL)
231 listing_tail->message = n;
236 listing_warning (message)
239 listing_message ("Warning:", message);
243 listing_error (message)
246 listing_message ("Error:", message);
252 static file_info_type *file_info_head;
254 static file_info_type *
255 file_info (file_name)
256 const char *file_name;
258 /* Find an entry with this file name */
259 file_info_type *p = file_info_head;
261 while (p != (file_info_type *) NULL)
263 if (strcmp (p->filename, file_name) == 0)
270 p = (file_info_type *) xmalloc (sizeof (file_info_type));
271 p->next = file_info_head;
273 p->filename = xmalloc ((unsigned long) strlen (file_name) + 1);
274 strcpy (p->filename, file_name);
278 p->file = fopen (p->filename, "r");
290 frag_wane (frag_now);
301 static unsigned int last_line = 0xffff;
302 static char *last_file = NULL;
305 as_where (&file, &line);
306 if (line != last_line || (last_file && file && strcmp(file, last_file)))
312 new = (list_info_type *) xmalloc (sizeof (list_info_type));
313 new->frag = frag_now;
315 new->file = file_info (file);
319 listing_tail->next = new;
326 new->next = (list_info_type *) NULL;
327 new->message = (char *) NULL;
328 new->edict = EDICT_NONE;
329 new->hll_file = (file_info_type *) NULL;
335 /* Attach all current frags to the previous line instead of the
336 current line. This is called by the MIPS backend when it discovers
337 that it needs to add some NOP instructions; the added NOP
338 instructions should go with the instruction that has the delay, not
339 with the new instruction. */
347 if (head == (list_info_type *) NULL
348 || head == listing_tail)
353 for (l = head; l->next != listing_tail; l = l->next)
356 for (f = frchain_now->frch_root; f != (fragS *) NULL; f = f->fr_next)
357 if (f->line == listing_tail)
360 listing_tail->frag = frag_now;
365 This function returns the next source line from the file supplied,
366 truncated to size. It appends a fake line to the end of each input
371 buffer_line (file, line, size)
372 file_info_type * file;
376 unsigned int count = 0;
381 /* If we couldn't open the file, return an empty line */
382 if (file->file == (FILE *) NULL || file->at_end)
387 if (file->linenum == 0)
390 c = fgetc (file->file);
392 size -= 1; /* leave room for null */
394 while (c != EOF && c != '\n')
400 c = fgetc (file->file);
416 static const char *fn;
418 static unsigned int eject; /* Eject pending */
419 static unsigned int page; /* Current page number */
420 static char *title; /* current title */
421 static char *subtitle; /* current subtitle */
422 static unsigned int on_page; /* number of lines printed on current page */
427 list_info_type *list;
429 /* Grope around, see if we can see a title or subtitle edict coming up
430 soon (we look down 10 lines of the page and see if it's there)*/
431 if ((eject || (on_page >= paper_height)) && paper_height != 0)
435 int had_subtitle = 0;
439 while (c != 0 && list)
441 if (list->edict == EDICT_SBTTL && !had_subtitle)
444 subtitle = list->edict_arg;
446 if (list->edict == EDICT_TITLE && !had_title)
449 title = list->edict_arg;
461 printf ("%s %s \t\t\tpage %d\n", LISTING_HEADER, fn, page);
462 printf ("%s\n", title);
463 printf ("%s\n", subtitle);
472 list_info_type * list;
474 list_info_type *first = list;
475 unsigned int address = (unsigned int) ~0;
480 unsigned int byte_in_frag;
483 /* Find first frag which says it belongs to this line */
485 while (frag && frag->line != list)
486 frag = frag->fr_next;
490 data_buffer_size = 0;
492 /* Dump all the frags which belong to this line */
493 while (frag_ptr != (fragS *) NULL && frag_ptr->line == first)
495 /* Print as many bytes from the fixed part as is sensible */
497 while (byte_in_frag < frag_ptr->fr_fix && data_buffer_size < sizeof (data_buffer) - 10)
501 address = frag_ptr->fr_address;
504 sprintf (data_buffer + data_buffer_size,
506 (frag_ptr->fr_literal[byte_in_frag]) & 0xff);
507 data_buffer_size += 2;
511 unsigned int var_rep_max = byte_in_frag;
512 unsigned int var_rep_idx = byte_in_frag;
514 /* Print as many bytes from the variable part as is sensible */
515 while (byte_in_frag < frag_ptr->fr_var * frag_ptr->fr_offset
516 && data_buffer_size < sizeof (data_buffer) - 10)
520 address = frag_ptr->fr_address;
522 sprintf (data_buffer + data_buffer_size,
524 (frag_ptr->fr_literal[var_rep_idx]) & 0xff);
526 data_buffer[data_buffer_size++] = '*';
527 data_buffer[data_buffer_size++] = '*';
529 data_buffer_size += 2;
534 if (var_rep_idx >= frag_ptr->fr_var)
535 var_rep_idx = var_rep_max;
539 frag_ptr = frag_ptr->fr_next;
541 data_buffer[data_buffer_size++] = 0;
551 print_lines (list, string, address)
552 list_info_type *list;
554 unsigned int address;
559 unsigned int byte_in_word = 0;
560 char *src = data_buffer;
562 /* Print the stuff on the first line */
564 nchars = (LISTING_WORD_SIZE * 2 + 1) * LISTING_LHS_WIDTH;
565 /* Print the hex for the first line */
568 printf ("% 4d ", list->line);
569 for (idx = 0; idx < nchars; idx++)
572 printf ("\t%s\n", string ? string : "");
581 printf ("% 4d ???? ", list->line);
585 printf ("% 4d %04x ", list->line, address);
588 /* And the data to go along with it */
591 while (*src && idx < nchars)
593 printf ("%c%c", src[0], src[1]);
596 if (byte_in_word == LISTING_WORD_SIZE)
605 for (; idx < nchars; idx++)
608 printf ("\t%s\n", string ? string : "");
613 printf ("**** %s\n", list->message);
619 lines < LISTING_LHS_CONT_LINES
623 nchars = ((LISTING_WORD_SIZE * 2) + 1) * LISTING_LHS_WIDTH_SECOND - 1;
625 /* Print any more lines of data, but more compactly */
626 printf ("% 4d ", list->line);
628 while (*src && idx < nchars)
630 printf ("%c%c", src[0], src[1]);
634 if (byte_in_word == LISTING_WORD_SIZE)
656 extern symbolS *symbol_rootP;
663 for (ptr = symbol_rootP; ptr != (symbolS *) NULL; ptr = symbol_next (ptr))
665 if (ptr->sy_frag->line)
667 if (S_GET_NAME (ptr))
669 char buf[30], fmt[8];
670 valueT val = S_GET_VALUE (ptr);
672 /* @@ Note that this is dependent on the compilation options,
673 not solely on the target characteristics. */
674 if (sizeof (val) == 4 && sizeof (int) == 4)
675 sprintf (buf, "%08lx", (unsigned long) val);
676 else if (sizeof (val) <= sizeof (unsigned long))
678 sprintf (fmt, "%%0%lulx",
679 (unsigned long) (sizeof (val) * 2));
680 sprintf (buf, fmt, (unsigned long) val);
683 else if (sizeof (val) > 4)
686 sprintf_vma (buf1, val);
687 strcpy (buf, "00000000");
688 strcpy (buf + 8 - strlen (buf1), buf1);
696 printf ("DEFINED SYMBOLS\n");
701 printf ("%20s:%-5d %s:%s %s\n",
702 ptr->sy_frag->line->file->filename,
703 ptr->sy_frag->line->line,
704 segment_name (S_GET_SEGMENT (ptr)),
705 buf, S_GET_NAME (ptr));
715 printf ("NO DEFINED SYMBOLS\n");
724 for (ptr = symbol_rootP; ptr != (symbolS *) NULL; ptr = symbol_next (ptr))
726 if (S_GET_NAME (ptr) && strlen (S_GET_NAME (ptr)) != 0)
728 if (ptr->sy_frag->line == 0
730 && !S_IS_REGISTER (ptr)
732 && S_GET_SEGMENT (ptr) != reg_section)
737 printf ("UNDEFINED SYMBOLS\n");
741 printf ("%s\n", S_GET_NAME (ptr));
749 printf ("NO UNDEFINED SYMBOLS\n");
756 print_source (current_file, list, buffer, width)
757 file_info_type *current_file;
758 list_info_type *list;
762 if (current_file->file)
764 while (current_file->linenum < list->hll_line
765 && !current_file->at_end)
767 char *p = buffer_line (current_file, buffer, width);
768 printf ("%4d:%-13s **** %s\n", current_file->linenum, current_file->filename, p);
775 /* Sometimes the user doesn't want to be bothered by the debugging
776 records inserted by the compiler, see if the line is suspicious */
779 debugging_pseudo (line)
782 while (isspace (*line))
790 if (strncmp (line, "def", 3) == 0)
792 if (strncmp (line, "val", 3) == 0)
794 if (strncmp (line, "scl", 3) == 0)
796 if (strncmp (line, "line", 4) == 0)
798 if (strncmp (line, "endef", 5) == 0)
800 if (strncmp (line, "ln", 2) == 0)
802 if (strncmp (line, "type", 4) == 0)
804 if (strncmp (line, "size", 4) == 0)
806 if (strncmp (line, "dim", 3) == 0)
808 if (strncmp (line, "tag", 3) == 0)
811 if (strncmp (line, "stabs", 5) == 0)
813 if (strncmp (line, "stabn", 5) == 0)
821 listing_listing (name)
824 list_info_type *list = head;
825 file_info_type *current_hll_file = (file_info_type *) NULL;
829 int show_listing = 1;
832 buffer = xmalloc (LISTING_RHS_WIDTH);
836 while (list != (list_info_type *) NULL && 0)
839 list->frag = list->next->frag;
849 width = LISTING_RHS_WIDTH > paper_width ? paper_width :
865 title = list->edict_arg;
868 subtitle = list->edict_arg;
874 if (show_listing > 0)
876 /* Scan down the list and print all the stuff which can be done
877 with this line (or lines). */
882 current_hll_file = list->hll_file;
885 if (current_hll_file && list->hll_line && listing & LISTING_HLL)
887 print_source (current_hll_file, list, buffer, width);
890 while (list->file->file
891 && list->file->linenum < list->line
892 && !list->file->at_end)
894 p = buffer_line (list->file, buffer, width);
896 if (!((listing & LISTING_NODEBUG) && debugging_pseudo (p)))
898 print_lines (list, p, calc_hex (list));
902 if (list->edict == EDICT_EJECT)
909 while (list->file->file
910 && list->file->linenum < list->line
911 && !list->file->at_end)
912 p = buffer_line (list->file, buffer, width);
927 if (listing & LISTING_NOFORM)
932 if (listing & LISTING_LISTING)
934 listing_listing (name);
937 if (listing & LISTING_SYMBOLS)
939 list_symbol_table ();
952 listing_eject (ignore)
955 listing_tail->edict = EDICT_EJECT;
959 listing_flags (ignore)
962 while ((*input_line_pointer++) && (*input_line_pointer != '\n'))
963 input_line_pointer++;
971 listing_tail->edict = on ? EDICT_LIST : EDICT_NOLIST;
976 listing_psize (ignore)
979 paper_height = get_absolute_expression ();
981 if (paper_height < 0 || paper_height > 1000)
984 as_warn ("strange paper height, set to no form");
986 if (*input_line_pointer == ',')
988 input_line_pointer++;
989 paper_width = get_absolute_expression ();
995 listing_title (depth)
1000 unsigned int length;
1003 if (*input_line_pointer == '\"')
1005 input_line_pointer++;
1006 start = input_line_pointer;
1008 while (*input_line_pointer)
1010 if (*input_line_pointer == '\"')
1012 length = input_line_pointer - start;
1013 ttl = xmalloc (length + 1);
1014 memcpy (ttl, start, length);
1016 listing_tail->edict = depth ? EDICT_SBTTL : EDICT_TITLE;
1017 listing_tail->edict_arg = ttl;
1018 input_line_pointer++;
1019 demand_empty_rest_of_line ();
1022 else if (*input_line_pointer == '\n')
1024 as_bad ("New line in title");
1025 demand_empty_rest_of_line ();
1030 input_line_pointer++;
1036 as_bad ("expecting title in quotes");
1043 listing_source_line (line)
1047 listing_tail->hll_line = line;
1053 listing_source_file (file)
1057 listing_tail->hll_file = file_info (file);
1065 /* Dummy functions for when compiled without listing enabled */
1068 listing_flags (ignore)
1082 listing_eject (ignore)
1089 listing_psize (ignore)
1096 listing_title (depth)
1110 listing_newline (name)
1117 listing_source_line (n)
1123 listing_source_file (n)