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
;
138 /* this structure rememebrs which line from which file goes into which
140 typedef struct list_info_struct
142 /* Frag which this line of source is nearest to */
144 /* The actual line in the source file */
146 /* Pointer to the file info struct for the file which this line
148 file_info_type
*file
;
151 struct list_info_struct
*next
;
154 /* Pointer to the file info struct for the high level language
155 source line that belongs here */
156 file_info_type
*hll_file
;
158 /* High level language source line */
162 /* Pointer to any error message associated with this line */
181 static struct list_info_struct
*head
;
182 struct list_info_struct
*listing_tail
;
184 extern fragS
*frag_now
;
187 static int paper_width
= 200;
188 static int paper_height
= 60;
191 /* this static array is used to keep the text of data to be printed
192 before the start of the line.
193 It is stored so we can give a bit more info on the next line. To much, and large
194 initialized arrays will use up lots of paper.
197 static char data_buffer
[100];
198 static unsigned int data_buffer_size
;
202 static void listing_message
PARAMS ((const char *name
, const char *message
));
203 static file_info_type
*file_info
PARAMS ((const char *file_name
));
204 static void new_frag
PARAMS ((void));
205 static char *buffer_line
PARAMS ((file_info_type
*file
,
206 char *line
, unsigned int size
));
207 static void listing_page
PARAMS ((list_info_type
*list
));
208 static unsigned int calc_hex
PARAMS ((list_info_type
*list
));
209 static void print_lines
PARAMS ((list_info_type
*list
,
211 unsigned int address
));
212 static void list_symbol_table
PARAMS ((void));
213 static void print_source
PARAMS ((file_info_type
*current_file
,
214 list_info_type
*list
,
216 unsigned int width
));
217 static int debugging_pseudo
PARAMS ((char *line
));
218 static void listing_listing
PARAMS ((char *name
));
222 listing_message (name
, message
)
226 unsigned int l
= strlen (name
) + strlen (message
) + 1;
227 char *n
= (char *) xmalloc (l
);
230 if (listing_tail
!= (list_info_type
*) NULL
)
232 listing_tail
->message
= n
;
241 listing_warning (message
)
244 listing_message ("Warning:", message
);
248 listing_error (message
)
251 listing_message ("Error:", message
);
257 static file_info_type
*file_info_head
;
259 static file_info_type
*
260 file_info (file_name
)
261 const char *file_name
;
263 /* Find an entry with this file name */
264 file_info_type
*p
= file_info_head
;
266 while (p
!= (file_info_type
*) NULL
)
268 if (strcmp (p
->filename
, file_name
) == 0)
275 p
= (file_info_type
*) xmalloc (sizeof (file_info_type
));
276 p
->next
= file_info_head
;
278 p
->filename
= xmalloc ((unsigned long) strlen (file_name
) + 1);
279 strcpy (p
->filename
, file_name
);
283 /* Do we really prefer binary mode for this?? */
284 p
->file
= fopen (p
->filename
, FOPEN_RB
);
296 frag_wane (frag_now
);
307 static unsigned int last_line
= 0xffff;
310 as_where (&file
, &line
);
311 if (line
!= last_line
)
316 new = (list_info_type
*) xmalloc (sizeof (list_info_type
));
317 new->frag
= frag_now
;
319 new->file
= file_info (file
);
323 listing_tail
->next
= new;
330 new->next
= (list_info_type
*) NULL
;
331 new->message
= (char *) NULL
;
332 new->edict
= EDICT_NONE
;
333 new->hll_file
= (file_info_type
*) NULL
;
339 /* Attach all current frags to the previous line instead of the
340 current line. This is called by the MIPS backend when it discovers
341 that it needs to add some NOP instructions; the added NOP
342 instructions should go with the instruction that has the delay, not
343 with the new instruction. */
351 if (head
== (list_info_type
*) NULL
352 || head
== listing_tail
)
357 for (l
= head
; l
->next
!= listing_tail
; l
= l
->next
)
360 for (f
= frchain_now
->frch_root
; f
!= (fragS
*) NULL
; f
= f
->fr_next
)
361 if (f
->line
== listing_tail
)
364 listing_tail
->frag
= frag_now
;
369 This function returns the next source line from the file supplied,
370 truncated to size. It appends a fake line to the end of each input
375 buffer_line (file
, line
, size
)
376 file_info_type
* file
;
380 unsigned int count
= 0;
385 /* If we couldn't open the file, return an empty line */
386 if (file
->file
== (FILE *) NULL
)
391 if (file
->linenum
== 0)
394 if (file
->end_pending
== 10)
397 fseek (file
->file
, 0, 0);
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
;
673 printf ("DEFINED SYMBOLS\n");
676 for (ptr
= symbol_rootP
; ptr
!= (symbolS
*) NULL
; ptr
= symbol_next (ptr
))
678 if (ptr
->sy_frag
->line
)
680 if (S_GET_NAME (ptr
))
683 valueT val
= S_GET_VALUE (ptr
);
685 /* @@ Note that this is dependent on the compilation options,
686 not solely on the target characteristics. */
687 if (sizeof (val
) == 4 && sizeof (int) == 4)
688 sprintf (buf
, "%08lx", (unsigned long) val
);
689 #if defined (BFD_ASSEMBLER) && defined (BFD64)
690 else if (sizeof (val
) > 4)
693 sprintf_vma (buf1
, val
);
694 strcpy (buf
, "00000000");
695 strcpy (buf
+ 8 - strlen (buf1
), buf1
);
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
));
716 printf ("UNDEFINED SYMBOLS\n");
720 for (ptr
= symbol_rootP
; ptr
!= (symbolS
*) NULL
; ptr
= symbol_next (ptr
))
722 if (S_GET_NAME (ptr
) && strlen (S_GET_NAME (ptr
)) != 0)
724 if (ptr
->sy_frag
->line
== 0
725 && S_GET_SEGMENT (ptr
) != reg_section
)
727 printf ("%s\n", S_GET_NAME (ptr
));
736 print_source (current_file
, list
, buffer
, width
)
737 file_info_type
*current_file
;
738 list_info_type
*list
;
742 if (current_file
->file
)
744 while (current_file
->linenum
< list
->hll_line
)
746 char *p
= buffer_line (current_file
, buffer
, width
);
747 printf ("%4d:%-13s **** %s\n", current_file
->linenum
, current_file
->filename
, p
);
754 /* Sometimes the user doesn't want to be bothered by the debugging
755 records inserted by the compiler, see if the line is suspicious */
758 debugging_pseudo (line
)
761 while (isspace (*line
))
769 if (strncmp (line
, "def", 3) == 0)
771 if (strncmp (line
, "val", 3) == 0)
773 if (strncmp (line
, "scl", 3) == 0)
775 if (strncmp (line
, "line", 4) == 0)
777 if (strncmp (line
, "endef", 5) == 0)
779 if (strncmp (line
, "ln", 2) == 0)
781 if (strncmp (line
, "type", 4) == 0)
783 if (strncmp (line
, "size", 4) == 0)
785 if (strncmp (line
, "dim", 3) == 0)
787 if (strncmp (line
, "tag", 3) == 0)
790 if (strncmp (line
, "stabs", 5) == 0)
792 if (strncmp (line
, "stabn", 5) == 0)
800 listing_listing (name
)
803 list_info_type
*list
= head
;
804 file_info_type
*current_hll_file
= (file_info_type
*) NULL
;
808 int show_listing
= 1;
811 buffer
= xmalloc (LISTING_RHS_WIDTH
);
815 while (list
!= (list_info_type
*) NULL
&& 0)
818 list
->frag
= list
->next
->frag
;
828 width
= LISTING_RHS_WIDTH
> paper_width
? paper_width
:
844 title
= list
->edict_arg
;
847 subtitle
= list
->edict_arg
;
853 if (show_listing
> 0)
855 /* Scan down the list and print all the stuff which can be done
856 with this line (or lines). */
861 current_hll_file
= list
->hll_file
;
864 if (current_hll_file
&& list
->hll_line
&& listing
& LISTING_HLL
)
866 print_source (current_hll_file
, list
, buffer
, width
);
869 p
= buffer_line (list
->file
, buffer
, width
);
871 if (!((listing
& LISTING_NODEBUG
) && debugging_pseudo (p
)))
873 print_lines (list
, p
, calc_hex (list
));
876 if (list
->edict
== EDICT_EJECT
)
884 p
= buffer_line (list
->file
, buffer
, width
);
899 if (listing
& LISTING_NOFORM
)
904 if (listing
& LISTING_LISTING
)
906 listing_listing (name
);
909 if (listing
& LISTING_SYMBOLS
)
911 list_symbol_table ();
924 listing_eject (ignore
)
927 listing_tail
->edict
= EDICT_EJECT
;
931 listing_flags (ignore
)
934 while ((*input_line_pointer
++) && (*input_line_pointer
!= '\n'))
935 input_line_pointer
++;
943 listing_tail
->edict
= on
? EDICT_LIST
: EDICT_NOLIST
;
948 listing_psize (ignore
)
951 paper_height
= get_absolute_expression ();
953 if (paper_height
< 0 || paper_height
> 1000)
956 as_warn ("strange paper height, set to no form");
958 if (*input_line_pointer
== ',')
960 input_line_pointer
++;
961 paper_width
= get_absolute_expression ();
967 listing_title (depth
)
975 if (*input_line_pointer
== '\"')
977 input_line_pointer
++;
978 start
= input_line_pointer
;
980 while (*input_line_pointer
)
982 if (*input_line_pointer
== '\"')
984 length
= input_line_pointer
- start
;
985 ttl
= xmalloc (length
+ 1);
986 memcpy (ttl
, start
, length
);
988 listing_tail
->edict
= depth
? EDICT_SBTTL
: EDICT_TITLE
;
989 listing_tail
->edict_arg
= ttl
;
990 input_line_pointer
++;
991 demand_empty_rest_of_line ();
994 else if (*input_line_pointer
== '\n')
996 as_bad ("New line in title");
997 demand_empty_rest_of_line ();
1002 input_line_pointer
++;
1008 as_bad ("expecting title in quotes");
1015 listing_source_line (line
)
1019 listing_tail
->hll_line
= line
;
1025 listing_source_file (file
)
1029 listing_tail
->hll_file
= file_info (file
);
1037 /* Dummy functions for when compiled without listing enabled */
1040 listing_flags (ignore
)
1054 listing_eject (ignore
)
1061 listing_psize (ignore
)
1068 listing_title (depth
)
1082 listing_newline (name
)
1089 listing_source_line (n
)
1095 listing_source_file (n
)
This page took 0.05133 seconds and 4 git commands to generate.