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
)
387 if (file
->linenum
== 0)
390 if (file
->end_pending
== 10)
394 fseek (file
->file
, 0, 0);
397 file
->linenum
= 9999999;
399 file
->end_pending
= 0;
401 c
= fgetc (file
->file
);
404 size
-= 1; /* leave room for null */
406 while (c
!= EOF
&& c
!= '\n')
412 c
= fgetc (file
->file
);
428 static const char *fn
;
430 static unsigned int eject
; /* Eject pending */
431 static unsigned int page
; /* Current page number */
432 static char *title
; /* current title */
433 static char *subtitle
; /* current subtitle */
434 static unsigned int on_page
; /* number of lines printed on current page */
439 list_info_type
*list
;
441 /* Grope around, see if we can see a title or subtitle edict coming up
442 soon (we look down 10 lines of the page and see if it's there)*/
443 if ((eject
|| (on_page
>= paper_height
)) && paper_height
!= 0)
447 int had_subtitle
= 0;
451 while (c
!= 0 && list
)
453 if (list
->edict
== EDICT_SBTTL
&& !had_subtitle
)
456 subtitle
= list
->edict_arg
;
458 if (list
->edict
== EDICT_TITLE
&& !had_title
)
461 title
= list
->edict_arg
;
473 printf ("%s %s \t\t\tpage %d\n", LISTING_HEADER
, fn
, page
);
474 printf ("%s\n", title
);
475 printf ("%s\n", subtitle
);
484 list_info_type
* list
;
486 list_info_type
*first
= list
;
487 unsigned int address
= (unsigned int) ~0;
492 unsigned int byte_in_frag
;
495 /* Find first frag which says it belongs to this line */
497 while (frag
&& frag
->line
!= list
)
498 frag
= frag
->fr_next
;
502 data_buffer_size
= 0;
504 /* Dump all the frags which belong to this line */
505 while (frag_ptr
!= (fragS
*) NULL
&& frag_ptr
->line
== first
)
507 /* Print as many bytes from the fixed part as is sensible */
509 while (byte_in_frag
< frag_ptr
->fr_fix
&& data_buffer_size
< sizeof (data_buffer
) - 10)
513 address
= frag_ptr
->fr_address
;
516 sprintf (data_buffer
+ data_buffer_size
,
518 (frag_ptr
->fr_literal
[byte_in_frag
]) & 0xff);
519 data_buffer_size
+= 2;
523 unsigned int var_rep_max
= byte_in_frag
;
524 unsigned int var_rep_idx
= byte_in_frag
;
526 /* Print as many bytes from the variable part as is sensible */
527 while (byte_in_frag
< frag_ptr
->fr_var
* frag_ptr
->fr_offset
528 && data_buffer_size
< sizeof (data_buffer
) - 10)
532 address
= frag_ptr
->fr_address
;
534 sprintf (data_buffer
+ data_buffer_size
,
536 (frag_ptr
->fr_literal
[var_rep_idx
]) & 0xff);
538 data_buffer
[data_buffer_size
++] = '*';
539 data_buffer
[data_buffer_size
++] = '*';
541 data_buffer_size
+= 2;
546 if (var_rep_idx
>= frag_ptr
->fr_var
)
547 var_rep_idx
= var_rep_max
;
551 frag_ptr
= frag_ptr
->fr_next
;
553 data_buffer
[data_buffer_size
++] = 0;
563 print_lines (list
, string
, address
)
564 list_info_type
*list
;
566 unsigned int address
;
571 unsigned int byte_in_word
= 0;
572 char *src
= data_buffer
;
574 /* Print the stuff on the first line */
576 nchars
= (LISTING_WORD_SIZE
* 2 + 1) * LISTING_LHS_WIDTH
;
577 /* Print the hex for the first line */
580 printf ("% 4d ", list
->line
);
581 for (idx
= 0; idx
< nchars
; idx
++)
584 printf ("\t%s\n", string
? string
: "");
593 printf ("% 4d ???? ", list
->line
);
597 printf ("% 4d %04x ", list
->line
, address
);
600 /* And the data to go along with it */
603 while (*src
&& idx
< nchars
)
605 printf ("%c%c", src
[0], src
[1]);
608 if (byte_in_word
== LISTING_WORD_SIZE
)
617 for (; idx
< nchars
; idx
++)
620 printf ("\t%s\n", string
? string
: "");
625 printf ("**** %s\n", list
->message
);
631 lines
< LISTING_LHS_CONT_LINES
635 nchars
= ((LISTING_WORD_SIZE
* 2) + 1) * LISTING_LHS_WIDTH_SECOND
- 1;
637 /* Print any more lines of data, but more compactly */
638 printf ("% 4d ", list
->line
);
640 while (*src
&& idx
< nchars
)
642 printf ("%c%c", src
[0], src
[1]);
646 if (byte_in_word
== LISTING_WORD_SIZE
)
668 extern symbolS
*symbol_rootP
;
675 for (ptr
= symbol_rootP
; ptr
!= (symbolS
*) NULL
; ptr
= symbol_next (ptr
))
677 if (ptr
->sy_frag
->line
)
679 if (S_GET_NAME (ptr
))
681 char buf
[30], fmt
[8];
682 valueT val
= S_GET_VALUE (ptr
);
684 /* @@ Note that this is dependent on the compilation options,
685 not solely on the target characteristics. */
686 if (sizeof (val
) == 4 && sizeof (int) == 4)
687 sprintf (buf
, "%08lx", (unsigned long) val
);
688 else if (sizeof (val
) <= sizeof (unsigned long))
690 sprintf (fmt
, "%%0%dlx", sizeof (val
) * 2);
691 sprintf (buf
, fmt
, (unsigned long) val
);
694 else if (sizeof (val
) > 4)
697 sprintf_vma (buf1
, val
);
698 strcpy (buf
, "00000000");
699 strcpy (buf
+ 8 - strlen (buf1
), buf1
);
707 printf ("DEFINED SYMBOLS\n");
712 printf ("%20s:%-5d %s:%s %s\n",
713 ptr
->sy_frag
->line
->file
->filename
,
714 ptr
->sy_frag
->line
->line
,
715 segment_name (S_GET_SEGMENT (ptr
)),
716 buf
, S_GET_NAME (ptr
));
726 printf ("NO DEFINED SYMBOLS\n");
735 for (ptr
= symbol_rootP
; ptr
!= (symbolS
*) NULL
; ptr
= symbol_next (ptr
))
737 if (S_GET_NAME (ptr
) && strlen (S_GET_NAME (ptr
)) != 0)
739 if (ptr
->sy_frag
->line
== 0
741 && !S_IS_REGISTER (ptr
)
743 && S_GET_SEGMENT (ptr
) != reg_section
)
748 printf ("UNDEFINED SYMBOLS\n");
752 printf ("%s\n", S_GET_NAME (ptr
));
760 printf ("NO UNDEFINED SYMBOLS\n");
767 print_source (current_file
, list
, buffer
, width
)
768 file_info_type
*current_file
;
769 list_info_type
*list
;
773 if (current_file
->file
)
775 while (current_file
->linenum
< list
->hll_line
776 && current_file
->end_pending
== 0)
778 char *p
= buffer_line (current_file
, buffer
, width
);
779 printf ("%4d:%-13s **** %s\n", current_file
->linenum
, current_file
->filename
, p
);
786 /* Sometimes the user doesn't want to be bothered by the debugging
787 records inserted by the compiler, see if the line is suspicious */
790 debugging_pseudo (line
)
793 while (isspace (*line
))
801 if (strncmp (line
, "def", 3) == 0)
803 if (strncmp (line
, "val", 3) == 0)
805 if (strncmp (line
, "scl", 3) == 0)
807 if (strncmp (line
, "line", 4) == 0)
809 if (strncmp (line
, "endef", 5) == 0)
811 if (strncmp (line
, "ln", 2) == 0)
813 if (strncmp (line
, "type", 4) == 0)
815 if (strncmp (line
, "size", 4) == 0)
817 if (strncmp (line
, "dim", 3) == 0)
819 if (strncmp (line
, "tag", 3) == 0)
822 if (strncmp (line
, "stabs", 5) == 0)
824 if (strncmp (line
, "stabn", 5) == 0)
832 listing_listing (name
)
835 list_info_type
*list
= head
;
836 file_info_type
*current_hll_file
= (file_info_type
*) NULL
;
840 int show_listing
= 1;
843 buffer
= xmalloc (LISTING_RHS_WIDTH
);
847 while (list
!= (list_info_type
*) NULL
&& 0)
850 list
->frag
= list
->next
->frag
;
860 width
= LISTING_RHS_WIDTH
> paper_width
? paper_width
:
876 title
= list
->edict_arg
;
879 subtitle
= list
->edict_arg
;
885 if (show_listing
> 0)
887 /* Scan down the list and print all the stuff which can be done
888 with this line (or lines). */
893 current_hll_file
= list
->hll_file
;
896 if (current_hll_file
&& list
->hll_line
&& listing
& LISTING_HLL
)
898 print_source (current_hll_file
, list
, buffer
, width
);
901 while (list
->file
->file
902 && list
->file
->linenum
< list
->line
903 && !list
->file
->end_pending
)
905 p
= buffer_line (list
->file
, buffer
, width
);
907 if (!((listing
& LISTING_NODEBUG
) && debugging_pseudo (p
)))
909 print_lines (list
, p
, calc_hex (list
));
913 if (list
->edict
== EDICT_EJECT
)
920 while (list
->file
->file
921 && list
->file
->linenum
< list
->line
922 && !list
->file
->end_pending
)
923 p
= buffer_line (list
->file
, buffer
, width
);
938 if (listing
& LISTING_NOFORM
)
943 if (listing
& LISTING_LISTING
)
945 listing_listing (name
);
948 if (listing
& LISTING_SYMBOLS
)
950 list_symbol_table ();
963 listing_eject (ignore
)
966 listing_tail
->edict
= EDICT_EJECT
;
970 listing_flags (ignore
)
973 while ((*input_line_pointer
++) && (*input_line_pointer
!= '\n'))
974 input_line_pointer
++;
982 listing_tail
->edict
= on
? EDICT_LIST
: EDICT_NOLIST
;
987 listing_psize (ignore
)
990 paper_height
= get_absolute_expression ();
992 if (paper_height
< 0 || paper_height
> 1000)
995 as_warn ("strange paper height, set to no form");
997 if (*input_line_pointer
== ',')
999 input_line_pointer
++;
1000 paper_width
= get_absolute_expression ();
1006 listing_title (depth
)
1011 unsigned int length
;
1014 if (*input_line_pointer
== '\"')
1016 input_line_pointer
++;
1017 start
= input_line_pointer
;
1019 while (*input_line_pointer
)
1021 if (*input_line_pointer
== '\"')
1023 length
= input_line_pointer
- start
;
1024 ttl
= xmalloc (length
+ 1);
1025 memcpy (ttl
, start
, length
);
1027 listing_tail
->edict
= depth
? EDICT_SBTTL
: EDICT_TITLE
;
1028 listing_tail
->edict_arg
= ttl
;
1029 input_line_pointer
++;
1030 demand_empty_rest_of_line ();
1033 else if (*input_line_pointer
== '\n')
1035 as_bad ("New line in title");
1036 demand_empty_rest_of_line ();
1041 input_line_pointer
++;
1047 as_bad ("expecting title in quotes");
1054 listing_source_line (line
)
1058 listing_tail
->hll_line
= line
;
1064 listing_source_file (file
)
1068 listing_tail
->hll_file
= file_info (file
);
1076 /* Dummy functions for when compiled without listing enabled */
1079 listing_flags (ignore
)
1093 listing_eject (ignore
)
1100 listing_psize (ignore
)
1107 listing_title (depth
)
1121 listing_newline (name
)
1128 listing_source_line (n
)
1134 listing_source_file (n
)
This page took 0.051777 seconds and 4 git commands to generate.