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
96 #include "input-file.h"
100 #ifndef LISTING_HEADER
101 #define LISTING_HEADER "GAS LISTING"
103 #ifndef LISTING_WORD_SIZE
104 #define LISTING_WORD_SIZE 4
106 #ifndef LISTING_LHS_WIDTH
107 #define LISTING_LHS_WIDTH 1
109 #ifndef LISTING_LHS_WIDTH_SECOND
110 #define LISTING_LHS_WIDTH_SECOND 1
112 #ifndef LISTING_RHS_WIDTH
113 #define LISTING_RHS_WIDTH 100
115 #ifndef LISTING_LHS_CONT_LINES
116 #define LISTING_LHS_CONT_LINES 4
122 /* This structure remembers which .s were used */
123 typedef struct file_info_struct
128 struct file_info_struct *next;
134 /* this structure rememebrs which line from which file goes into which
136 typedef struct list_info_struct
138 /* Frag which this line of source is nearest to */
140 /* The actual line in the source file */
142 /* Pointer to the file info struct for the file which this line
144 file_info_type *file;
147 struct list_info_struct *next;
150 /* Pointer to the file info struct for the high level language
151 source line that belongs here */
152 file_info_type *hll_file;
154 /* High level language source line */
158 /* Pointer to any error message associated with this line */
175 static struct list_info_struct *head;
176 struct list_info_struct *listing_tail;
178 extern unsigned int physical_input_line;
179 extern fragS *frag_now;
182 static int paper_width = 200;
183 static int paper_height = 60;
186 /* this static array is used to keep the text of data to be printed
187 before the start of the line.
188 It is stored so we can give a bit more info on the next line. To much, and large
189 initialized arrays will use up lots of paper.
192 static char data_buffer[100];
193 static unsigned int data_buffer_size;
197 DEFUN(listing_message,(name, message),
201 unsigned int l = strlen(name) + strlen(message)+1;
205 if(listing_tail != (list_info_type *)NULL)
207 listing_tail->message = n;
216 DEFUN(listing_warning,(message),
219 listing_message("Warning:", message);
223 DEFUN(listing_error,(message),
226 listing_message("Error:", message);
232 static file_info_type *file_info_head;
234 static file_info_type *
235 DEFUN(file_info, (file_name),
238 /* Find an entry with this file name */
239 file_info_type *p = file_info_head;
241 while (p != (file_info_type *)NULL)
243 if (strcmp(p->filename, file_name) == 0)
250 p = (file_info_type *)xmalloc(sizeof(file_info_type));
251 p->next = file_info_head;
253 p->filename = xmalloc(strlen(file_name)+1);
254 strcpy(p->filename, file_name);
258 p->file = fopen(p->filename,"r");
274 DEFUN(listing_newline,(ps),
278 extern char *file_name;
279 static unsigned int last_line =0xffff ;
283 if (physical_input_line != last_line)
285 last_line = physical_input_line;
288 new = (list_info_type *)malloc(sizeof(list_info_type));
289 new->frag = frag_now;
290 new->line = physical_input_line ;
291 new->file = file_info(file_name);
295 listing_tail->next = new;
302 new->next = (list_info_type *)NULL;
303 new->message = (char *)NULL;
304 new->edict = EDICT_NONE;
305 new->hll_file = (file_info_type*)NULL;
313 This function returns the next source line from the file supplied,
314 truncated to size. It appends a fake line to the end of each input
319 DEFUN(buffer_line,(file, line, size),
320 file_info_type *file AND
324 unsigned int count = 0;
329 /* If we couldn't open the file, return an empty line */
330 if (file->file == (FILE*)NULL)
335 if (file->end_pending == 10) {
339 file->end_pending = 0;
341 c = fgetc(file->file);
342 size -= 1; /* leave room for null */
344 while (c != EOF && c != '\n')
350 c= fgetc(file->file);
354 file->end_pending ++;
367 static unsigned int eject; /* Eject pending */
368 static unsigned int page; /* Current page number */
369 static char *title; /* current title */
370 static char *subtitle; /* current subtitle */
371 static unsigned int on_page; /* number of lines printed on current page */
375 DEFUN(listing_page,(list),
376 list_info_type *list)
378 /* Grope around, see if we can see a title or subtitle edict coming up
379 soon (we look down 10 lines of the page and see if it's there)*/
380 if ((eject || (on_page >= paper_height)) && paper_height != 0)
384 int had_subtitle = 0;
388 while (c != 0 && list)
390 if (list->edict == EDICT_SBTTL && !had_subtitle)
393 subtitle = list->edict_arg;
395 if (list->edict == EDICT_TITLE && !had_title)
398 title = list->edict_arg;
410 printf("%s %s \t\t\tpage %d\n", LISTING_HEADER, fn, page);
411 printf("%s\n", title);
412 printf("%s\n", subtitle);
420 DEFUN(calc_hex,(list),
421 list_info_type *list)
423 list_info_type *first = list;
424 list_info_type *last = first;
425 unsigned int address = ~0;
430 unsigned int byte_in_frag = 0;
434 /* Find first frag which says it belongs to this line */
436 while (frag && frag->line != list)
437 frag = frag->fr_next;
441 data_buffer_size = 0;
443 /* Dump all the frags which belong to this line */
444 while (frag_ptr != (fragS *)NULL && frag_ptr->line == first)
446 /* Print as many bytes from the fixed part as is sensible */
447 while(byte_in_frag < frag_ptr->fr_fix && data_buffer_size < sizeof(data_buffer)-10)
451 address = frag_ptr->fr_address;
454 sprintf(data_buffer + data_buffer_size,
456 (frag_ptr->fr_literal[byte_in_frag]) & 0xff);
457 data_buffer_size += 2;
461 unsigned int var_rep_max = byte_in_frag;
462 unsigned int var_rep_idx = byte_in_frag;
464 /* Print as many bytes from the variable part as is sensible */
465 while (byte_in_frag < frag_ptr->fr_var * frag_ptr->fr_offset
466 && data_buffer_size < sizeof(data_buffer)-10)
470 address = frag_ptr->fr_address;
472 sprintf(data_buffer + data_buffer_size,
474 (frag_ptr->fr_literal[var_rep_idx]) & 0xff);
476 data_buffer[data_buffer_size++] = '*';
477 data_buffer[data_buffer_size++] = '*';
479 data_buffer_size +=2;
484 if (var_rep_idx >= frag_ptr->fr_var)
485 var_rep_idx = var_rep_max;
489 frag_ptr = frag_ptr->fr_next;
491 data_buffer[data_buffer_size++] = 0;
501 DEFUN(print_lines,(list, string, address),
502 list_info_type *list AND
504 unsigned int address)
509 unsigned int byte_in_word =0;
510 char *src = data_buffer;
512 /* Print the stuff on the first line */
514 nchars = (LISTING_WORD_SIZE*2 +1) * LISTING_LHS_WIDTH ;
515 /* Print the hex for the first line */
518 printf("% 4d ", list->line);
519 for (idx = 0; idx < nchars; idx++)
522 printf("\t%s\n", string ? string : "");
531 printf("% 4d ???? ", list->line);
535 printf("% 4d %04x ", list->line, address);
538 /* And the data to go along with it */
541 while (*src && idx < nchars)
543 printf("%c%c", src[0], src[1]);
546 if (byte_in_word == LISTING_WORD_SIZE)
555 for (;idx < nchars; idx++)
558 printf("\t%s\n", string ? string : "");
563 printf("**** %s\n",list->message);
569 lines < LISTING_LHS_CONT_LINES
572 nchars = ((LISTING_WORD_SIZE*2) +1) * LISTING_LHS_WIDTH_SECOND -1;
574 /* Print any more lines of data, but more compactly */
575 printf("% 4d ", list->line);
577 while (*src && idx < nchars)
579 printf("%c%c", src[0], src[1]);
583 if (byte_in_word == LISTING_WORD_SIZE)
607 DEFUN_VOID(list_symbol_table)
609 extern symbolS *symbol_rootP;
614 printf("DEFINED SYMBOLS\n");
617 for (ptr = symbol_rootP; ptr != (symbolS*)NULL; ptr = symbol_next(ptr))
619 if (ptr->sy_frag->line)
621 if (strlen(S_GET_NAME(ptr)))
623 printf("%20s:%-5d %2d:%08x %s \n",
624 ptr->sy_frag->line->file->filename,
625 ptr->sy_frag->line->line,
639 printf("UNDEFINED SYMBOLS\n");
643 for (ptr = symbol_rootP; ptr != (symbolS*)NULL; ptr = symbol_next(ptr))
645 if (ptr && strlen(S_GET_NAME(ptr)) != 0)
647 if (ptr->sy_frag->line == 0)
649 printf("%s\n", S_GET_NAME(ptr));
658 DEFUN(print_source,(current_file, list, buffer, width),
659 file_info_type *current_file AND
660 list_info_type *list AND
664 if (current_file->file) {
665 while (current_file->linenum < list->hll_line)
667 char * p = buffer_line(current_file, buffer, width);
668 printf("%4d:%-13s **** %s\n", current_file->linenum, current_file->filename, p);
675 /* Sometimes the user doesn't want to be bothered by the debugging
676 records inserted by the compiler, see if the line is suspicioous */
679 DEFUN(debugging_pseudo,(line),
682 while (isspace(*line))
685 if(*line != '.') return 0;
689 if (strncmp(line, "def",3) == 0) return 1;
690 if (strncmp(line, "val",3) == 0) return 1;
691 if (strncmp(line, "scl",3) == 0) return 1;
692 if (strncmp(line, "line",4) == 0) return 1;
693 if (strncmp(line, "endef",5) == 0) return 1;
694 if (strncmp(line, "ln",2) ==0) return 1;
695 if (strncmp(line, "type",4) ==0) return 1;
696 if (strncmp(line, "size",4) == 0) return 1;
697 if (strncmp(line, "dim",3) ==0) return 1;
698 if (strncmp(line, "tag",3) == 0) return 1;
705 DEFUN(listing_listing,(name),
708 list_info_type *list = head;
709 file_info_type *current_hll_file = (file_info_type *)NULL;
711 unsigned int page= 1;
712 unsigned int prev = 0;
716 unsigned int addr = 0;
718 int show_listing = 1;
721 buffer = malloc(LISTING_RHS_WIDTH);
725 while (list != (list_info_type *)NULL && 0)
728 list->frag = list->next->frag;
738 width = LISTING_RHS_WIDTH > paper_width ? paper_width :
741 switch (list->edict) {
753 title = list->edict_arg;
756 subtitle = list->edict_arg;
762 if (show_listing > 0)
764 /* Scan down the list and print all the stuff which can be done
765 with this line (or lines) */
770 current_hll_file = list->hll_file;
773 if (current_hll_file && list->hll_line && listing & LISTING_HLL)
775 print_source(current_hll_file, list, buffer, width);
778 p = buffer_line(list->file, buffer, width);
780 if (! ((listing & LISTING_NODEBUG) && debugging_pseudo(p)))
782 print_lines(list, p, calc_hex(list));
785 if (list->edict == EDICT_EJECT)
793 p = buffer_line(list->file, buffer, width);
802 DEFUN(listing_print,(name),
808 if (listing & LISTING_NOFORM)
813 if (listing & LISTING_LISTING)
815 listing_listing(name);
818 if (listing & LISTING_SYMBOLS)
826 DEFUN(listing_file,(name),
833 DEFUN_VOID(listing_eject)
835 listing_tail->edict = EDICT_EJECT;
839 DEFUN_VOID(listing_flags)
844 DEFUN(listing_list,(on),
847 listing_tail->edict = on ? EDICT_LIST : EDICT_NOLIST;
852 DEFUN_VOID(listing_psize)
854 paper_height = get_absolute_expression();
856 if (paper_height < 0 || paper_height > 1000)
859 as_warn("strantge paper height, set to no form");
861 if (*input_line_pointer == ',')
863 input_line_pointer++;
864 paper_width = get_absolute_expression();
870 DEFUN(listing_title,(depth),
878 if (*input_line_pointer=='\"') {
879 input_line_pointer++;
880 start = input_line_pointer;
882 while (*input_line_pointer)
884 if (*input_line_pointer == '\"')
886 length = input_line_pointer - start;
887 title = malloc(length + 1);
888 memcpy(title, start, length);
890 listing_tail->edict = depth ? EDICT_SBTTL : EDICT_TITLE;
891 listing_tail->edict_arg = title;
892 input_line_pointer++;
893 demand_empty_rest_of_line();
896 else if (*input_line_pointer == '\n')
898 as_bad("New line in title");
899 demand_empty_rest_of_line();
904 input_line_pointer++;
910 as_bad("expecting title in quotes");
917 DEFUN(listing_source_line,(line),
921 listing_tail->hll_line = line;
927 DEFUN(listing_source_file,(file),
930 listing_tail->hll_file = file_info(file);
938 /* Dummy functions for when compiled without listing enabled */
941 DEFUN_VOID(listing_flags)
946 void DEFUN_VOID(listing_list)
951 void DEFUN_VOID(listing_eject)
955 void DEFUN(listing_psize)
960 void DEFUN(listing_title, (depth),
966 DEFUN(listing_file,(name),
972 void DEFUN(listing_newline,(name),
978 void DEFUN(listing_source_line,(n),
983 void DEFUN(listing_source_file, (n),