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, 59 Temple Place - Suite 330, Boston, MA 02111-1307, 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
;
184 static int paper_width
= 200;
185 static int paper_height
= 60;
187 /* File to output listings to. */
188 static FILE *list_file
;
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
;
308 if (now_seg
== absolute_section
)
311 as_where (&file
, &line
);
312 if (line
!= last_line
|| (last_file
&& file
&& strcmp(file
, last_file
)))
318 new = (list_info_type
*) xmalloc (sizeof (list_info_type
));
319 new->frag
= frag_now
;
321 new->file
= file_info (file
);
325 listing_tail
->next
= new;
332 new->next
= (list_info_type
*) NULL
;
333 new->message
= (char *) NULL
;
334 new->edict
= EDICT_NONE
;
335 new->hll_file
= (file_info_type
*) NULL
;
341 /* Attach all current frags to the previous line instead of the
342 current line. This is called by the MIPS backend when it discovers
343 that it needs to add some NOP instructions; the added NOP
344 instructions should go with the instruction that has the delay, not
345 with the new instruction. */
353 if (head
== (list_info_type
*) NULL
354 || head
== listing_tail
)
359 for (l
= head
; l
->next
!= listing_tail
; l
= l
->next
)
362 for (f
= frchain_now
->frch_root
; f
!= (fragS
*) NULL
; f
= f
->fr_next
)
363 if (f
->line
== listing_tail
)
366 listing_tail
->frag
= frag_now
;
371 This function returns the next source line from the file supplied,
372 truncated to size. It appends a fake line to the end of each input
377 buffer_line (file
, line
, size
)
378 file_info_type
* file
;
382 unsigned int count
= 0;
387 /* If we couldn't open the file, return an empty line */
388 if (file
->file
== (FILE *) NULL
|| file
->at_end
)
393 if (file
->linenum
== 0)
396 c
= fgetc (file
->file
);
398 size
-= 1; /* leave room for null */
400 while (c
!= EOF
&& c
!= '\n')
406 c
= fgetc (file
->file
);
422 static const char *fn
;
424 static unsigned int eject
; /* Eject pending */
425 static unsigned int page
; /* Current page number */
426 static char *title
; /* current title */
427 static char *subtitle
; /* current subtitle */
428 static unsigned int on_page
; /* number of lines printed on current page */
433 list_info_type
*list
;
435 /* Grope around, see if we can see a title or subtitle edict coming up
436 soon (we look down 10 lines of the page and see if it's there)*/
437 if ((eject
|| (on_page
>= paper_height
)) && paper_height
!= 0)
441 int had_subtitle
= 0;
445 while (c
!= 0 && list
)
447 if (list
->edict
== EDICT_SBTTL
&& !had_subtitle
)
450 subtitle
= list
->edict_arg
;
452 if (list
->edict
== EDICT_TITLE
&& !had_title
)
455 title
= list
->edict_arg
;
464 fprintf (list_file
, "\f");
467 fprintf (list_file
, "%s %s \t\t\tpage %d\n", LISTING_HEADER
, fn
, page
);
468 fprintf (list_file
, "%s\n", title
);
469 fprintf (list_file
, "%s\n", subtitle
);
478 list_info_type
* list
;
480 list_info_type
*first
= list
;
481 unsigned int address
= (unsigned int) ~0;
486 unsigned int byte_in_frag
;
489 /* Find first frag which says it belongs to this line */
491 while (frag
&& frag
->line
!= list
)
492 frag
= frag
->fr_next
;
496 data_buffer_size
= 0;
498 /* Dump all the frags which belong to this line */
499 while (frag_ptr
!= (fragS
*) NULL
&& frag_ptr
->line
== first
)
501 /* Print as many bytes from the fixed part as is sensible */
503 while (byte_in_frag
< frag_ptr
->fr_fix
&& data_buffer_size
< sizeof (data_buffer
) - 10)
507 address
= frag_ptr
->fr_address
;
510 sprintf (data_buffer
+ data_buffer_size
,
512 (frag_ptr
->fr_literal
[byte_in_frag
]) & 0xff);
513 data_buffer_size
+= 2;
517 unsigned int var_rep_max
= byte_in_frag
;
518 unsigned int var_rep_idx
= byte_in_frag
;
520 /* Print as many bytes from the variable part as is sensible */
522 < frag_ptr
->fr_fix
+ frag_ptr
->fr_var
* frag_ptr
->fr_offset
)
523 && data_buffer_size
< sizeof (data_buffer
) - 10)
527 address
= frag_ptr
->fr_address
;
529 sprintf (data_buffer
+ data_buffer_size
,
531 (frag_ptr
->fr_literal
[var_rep_idx
]) & 0xff);
533 data_buffer
[data_buffer_size
++] = '*';
534 data_buffer
[data_buffer_size
++] = '*';
536 data_buffer_size
+= 2;
541 if (var_rep_idx
>= frag_ptr
->fr_fix
+ frag_ptr
->fr_var
)
542 var_rep_idx
= var_rep_max
;
546 frag_ptr
= frag_ptr
->fr_next
;
548 data_buffer
[data_buffer_size
++] = 0;
558 print_lines (list
, string
, address
)
559 list_info_type
*list
;
561 unsigned int address
;
566 unsigned int byte_in_word
= 0;
567 char *src
= data_buffer
;
569 /* Print the stuff on the first line */
571 nchars
= (LISTING_WORD_SIZE
* 2 + 1) * LISTING_LHS_WIDTH
;
572 /* Print the hex for the first line */
575 fprintf (list_file
, "% 4d ", list
->line
);
576 for (idx
= 0; idx
< nchars
; idx
++)
577 fprintf (list_file
, " ");
579 fprintf (list_file
, "\t%s\n", string
? string
: "");
588 fprintf (list_file
, "% 4d ???? ", list
->line
);
592 fprintf (list_file
, "% 4d %04x ", list
->line
, address
);
595 /* And the data to go along with it */
598 while (*src
&& idx
< nchars
)
600 fprintf (list_file
, "%c%c", src
[0], src
[1]);
603 if (byte_in_word
== LISTING_WORD_SIZE
)
605 fprintf (list_file
, " ");
612 for (; idx
< nchars
; idx
++)
613 fprintf (list_file
, " ");
615 fprintf (list_file
, "\t%s\n", string
? string
: "");
620 fprintf (list_file
, "**** %s\n", list
->message
);
626 lines
< LISTING_LHS_CONT_LINES
630 nchars
= ((LISTING_WORD_SIZE
* 2) + 1) * LISTING_LHS_WIDTH_SECOND
- 1;
632 /* Print any more lines of data, but more compactly */
633 fprintf (list_file
, "% 4d ", list
->line
);
635 while (*src
&& idx
< nchars
)
637 fprintf (list_file
, "%c%c", src
[0], src
[1]);
641 if (byte_in_word
== LISTING_WORD_SIZE
)
643 fprintf (list_file
, " ");
649 fprintf (list_file
, "\n");
663 extern symbolS
*symbol_rootP
;
670 for (ptr
= symbol_rootP
; ptr
!= (symbolS
*) NULL
; ptr
= symbol_next (ptr
))
672 if (ptr
->sy_frag
->line
)
674 if (S_GET_NAME (ptr
))
676 char buf
[30], fmt
[8];
677 valueT val
= S_GET_VALUE (ptr
);
679 /* @@ Note that this is dependent on the compilation options,
680 not solely on the target characteristics. */
681 if (sizeof (val
) == 4 && sizeof (int) == 4)
682 sprintf (buf
, "%08lx", (unsigned long) val
);
683 else if (sizeof (val
) <= sizeof (unsigned long))
685 sprintf (fmt
, "%%0%lulx",
686 (unsigned long) (sizeof (val
) * 2));
687 sprintf (buf
, fmt
, (unsigned long) val
);
690 else if (sizeof (val
) > 4)
693 sprintf_vma (buf1
, val
);
694 strcpy (buf
, "00000000");
695 strcpy (buf
+ 8 - strlen (buf1
), buf1
);
703 fprintf (list_file
, "DEFINED SYMBOLS\n");
708 fprintf (list_file
, "%20s:%-5d %s:%s %s\n",
709 ptr
->sy_frag
->line
->file
->filename
,
710 ptr
->sy_frag
->line
->line
,
711 segment_name (S_GET_SEGMENT (ptr
)),
712 buf
, S_GET_NAME (ptr
));
722 fprintf (list_file
, "NO DEFINED SYMBOLS\n");
725 fprintf (list_file
, "\n");
731 for (ptr
= symbol_rootP
; ptr
!= (symbolS
*) NULL
; ptr
= symbol_next (ptr
))
733 if (S_GET_NAME (ptr
) && strlen (S_GET_NAME (ptr
)) != 0)
735 if (ptr
->sy_frag
->line
== 0
737 && !S_IS_REGISTER (ptr
)
739 && S_GET_SEGMENT (ptr
) != reg_section
)
744 fprintf (list_file
, "UNDEFINED SYMBOLS\n");
748 fprintf (list_file
, "%s\n", S_GET_NAME (ptr
));
756 fprintf (list_file
, "NO UNDEFINED SYMBOLS\n");
763 print_source (current_file
, list
, buffer
, width
)
764 file_info_type
*current_file
;
765 list_info_type
*list
;
769 if (current_file
->file
)
771 while (current_file
->linenum
< list
->hll_line
772 && !current_file
->at_end
)
774 char *p
= buffer_line (current_file
, buffer
, width
);
775 fprintf (list_file
, "%4d:%-13s **** %s\n", current_file
->linenum
,
776 current_file
->filename
, p
);
783 /* Sometimes the user doesn't want to be bothered by the debugging
784 records inserted by the compiler, see if the line is suspicious */
787 debugging_pseudo (line
)
790 while (isspace (*line
))
798 if (strncmp (line
, "def", 3) == 0)
800 if (strncmp (line
, "val", 3) == 0)
802 if (strncmp (line
, "scl", 3) == 0)
804 if (strncmp (line
, "line", 4) == 0)
806 if (strncmp (line
, "endef", 5) == 0)
808 if (strncmp (line
, "ln", 2) == 0)
810 if (strncmp (line
, "type", 4) == 0)
812 if (strncmp (line
, "size", 4) == 0)
814 if (strncmp (line
, "dim", 3) == 0)
816 if (strncmp (line
, "tag", 3) == 0)
819 if (strncmp (line
, "stabs", 5) == 0)
821 if (strncmp (line
, "stabn", 5) == 0)
829 listing_listing (name
)
832 list_info_type
*list
= head
;
833 file_info_type
*current_hll_file
= (file_info_type
*) NULL
;
837 int show_listing
= 1;
840 buffer
= xmalloc (LISTING_RHS_WIDTH
);
844 while (list
!= (list_info_type
*) NULL
&& 0)
847 list
->frag
= list
->next
->frag
;
857 width
= LISTING_RHS_WIDTH
> paper_width
? paper_width
:
873 title
= list
->edict_arg
;
876 subtitle
= list
->edict_arg
;
882 if (show_listing
> 0)
884 /* Scan down the list and print all the stuff which can be done
885 with this line (or lines). */
890 current_hll_file
= list
->hll_file
;
893 if (current_hll_file
&& list
->hll_line
&& listing
& LISTING_HLL
)
895 print_source (current_hll_file
, list
, buffer
, width
);
898 while (list
->file
->file
899 && list
->file
->linenum
< list
->line
900 && !list
->file
->at_end
)
902 p
= buffer_line (list
->file
, buffer
, width
);
904 if (!((listing
& LISTING_NODEBUG
) && debugging_pseudo (p
)))
906 print_lines (list
, p
, calc_hex (list
));
910 if (list
->edict
== EDICT_EJECT
)
917 while (list
->file
->file
918 && list
->file
->linenum
< list
->line
919 && !list
->file
->at_end
)
920 p
= buffer_line (list
->file
, buffer
, width
);
939 list_file
= fopen (name
, "w");
940 if (list_file
== NULL
)
942 as_perror ("can't open list file: %s", name
);
947 if (listing
& LISTING_NOFORM
)
952 if (listing
& LISTING_LISTING
)
954 listing_listing (name
);
957 if (listing
& LISTING_SYMBOLS
)
959 list_symbol_table ();
972 listing_eject (ignore
)
976 listing_tail
->edict
= EDICT_EJECT
;
980 listing_flags (ignore
)
983 while ((*input_line_pointer
++) && (*input_line_pointer
!= '\n'))
984 input_line_pointer
++;
993 listing_tail
->edict
= on
? EDICT_LIST
: EDICT_NOLIST
;
998 listing_psize (width_only
)
1003 paper_height
= get_absolute_expression ();
1005 if (paper_height
< 0 || paper_height
> 1000)
1008 as_warn ("strange paper height, set to no form");
1011 if (*input_line_pointer
!= ',')
1013 demand_empty_rest_of_line ();
1017 ++input_line_pointer
;
1020 paper_width
= get_absolute_expression ();
1022 demand_empty_rest_of_line ();
1026 listing_nopage (ignore
)
1033 listing_title (depth
)
1039 unsigned int length
;
1042 if (*input_line_pointer
!= '\"')
1047 ++input_line_pointer
;
1050 start
= input_line_pointer
;
1052 while (*input_line_pointer
)
1055 ? *input_line_pointer
== '\"'
1056 : is_end_of_line
[(unsigned char) *input_line_pointer
])
1060 length
= input_line_pointer
- start
;
1061 ttl
= xmalloc (length
+ 1);
1062 memcpy (ttl
, start
, length
);
1064 listing_tail
->edict
= depth
? EDICT_SBTTL
: EDICT_TITLE
;
1065 listing_tail
->edict_arg
= ttl
;
1068 input_line_pointer
++;
1069 demand_empty_rest_of_line ();
1072 else if (*input_line_pointer
== '\n')
1074 as_bad ("New line in title");
1075 demand_empty_rest_of_line ();
1080 input_line_pointer
++;
1088 listing_source_line (line
)
1094 listing_tail
->hll_line
= line
;
1100 listing_source_file (file
)
1104 listing_tail
->hll_file
= file_info (file
);
1112 /* Dummy functions for when compiled without listing enabled */
1115 listing_flags (ignore
)
1129 listing_eject (ignore
)
1136 listing_psize (ignore
)
1143 listing_nopage (ignore
)
1150 listing_title (depth
)
1164 listing_newline (name
)
1171 listing_source_line (n
)
1177 listing_source_file (n
)
This page took 0.053742 seconds and 4 git commands to generate.