/* listing.c - mainting assembly listings
- Copyright (C) 1991, 1992 Free Software Foundation, Inc.
+ Copyright (C) 1991, 92, 93, 94, 95, 96, 1997 Free Software Foundation, Inc.
This file is part of GAS, the GNU Assembler.
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
-along with GAS; see the file COPYING. If not, write to
-the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
+along with GAS; see the file COPYING. If not, write to the Free
+Software Foundation, 59 Temple Place - Suite 330, Boston, MA
+02111-1307, USA. */
/*
Contributed by Steve Chamberlain
A listing page looks like:
-
+
LISTING_HEADER sourcefilename pagenumber
TITLE LINE
SUBTITLE LINE
If not overridden, the listing commands are:
- .title "stuff"
- Put "stuff" onto the title line
+ .title "stuff"
+ Put "stuff" onto the title line
.sbttl "stuff"
Put stuff onto the subtitle line
Set the paper size to X wide and Y high. Setting a psize Y of
zero will suppress form feeds except where demanded by .eject
- If the counter goes below zero, listing is suppressed.
+ If the counter goes below zero, listing is suppressed.
Listings are a maintained by read calling various listing_<foo>
on a line
*/
-#include "as.h"
-<<<<<<< listing.c
-#include <ansidecl.h>
-=======
+#include <ctype.h>
->>>>>>> 1.13
+#include "as.h"
#include <obstack.h>
#include "input-file.h"
-#include "targ-cpu.h"
-
-char *malloc();
+#include "subsegs.h"
#ifndef NO_LISTING
+
#ifndef LISTING_HEADER
#define LISTING_HEADER "GAS LISTING"
#endif
#ifndef LISTING_RHS_WIDTH
#define LISTING_RHS_WIDTH 100
#endif
-#ifndef LISTING_LHS_CONT_LINES
+#ifndef LISTING_LHS_CONT_LINES
#define LISTING_LHS_CONT_LINES 4
#endif
-
-
-
/* This structure remembers which .s were used */
-typedef struct file_info_struct
+typedef struct file_info_struct
{
+ struct file_info_struct *next;
char *filename;
+ long pos;
int linenum;
- FILE *file;
- struct file_info_struct *next;
- int end_pending;
-
-} file_info_type ;
+ int at_end;
+}
+file_info_type;
+
-
/* this structure rememebrs which line from which file goes into which
frag */
-typedef struct list_info_struct
+struct list_info_struct
{
/* Frag which this line of source is nearest to */
fragS *frag;
+
/* The actual line in the source file */
unsigned int line;
/* Pointer to the file info struct for the file which this line
belongs to */
file_info_type *file;
+ /* The expanded text of any macro that may have been executing. */
+ char *line_contents;
+
/* Next in list */
struct list_info_struct *next;
-
/* Pointer to the file info struct for the high level language
source line that belongs here */
file_info_type *hll_file;
-
/* High level language source line */
int hll_line;
-
/* Pointer to any error message associated with this line */
char *message;
-
- enum
- {
- EDICT_NONE,
- EDICT_SBTTL,
- EDICT_TITLE,
- EDICT_NOLIST,
- EDICT_LIST,
- EDICT_EJECT
- } edict;
+
+ enum
+ {
+ EDICT_NONE,
+ EDICT_SBTTL,
+ EDICT_TITLE,
+ EDICT_NOLIST,
+ EDICT_LIST,
+ EDICT_NOLIST_NEXT,
+ EDICT_EJECT
+ } edict;
char *edict_arg;
-
-} list_info_type;
+ /* Nonzero if this line is to be omitted because it contains
+ debugging information. This can become a flags field if we come
+ up with more information to store here. */
+ int debugging;
+};
+
+typedef struct list_info_struct list_info_type;
static struct list_info_struct *head;
struct list_info_struct *listing_tail;
extern int listing;
-extern unsigned int physical_input_line;
-extern fragS *frag_now;
-
static int paper_width = 200;
static int paper_height = 60;
+/* File to output listings to. */
+static FILE *list_file;
+
+/* This static array is used to keep the text of data to be printed
+ before the start of the line. */
+
+#define MAX_BYTES \
+ (((LISTING_WORD_SIZE * 2) + 1) * listing_lhs_width \
+ + ((((LISTING_WORD_SIZE * 2) + 1) * listing_lhs_width_second) \
+ * listing_lhs_cont_lines) \
+ + 20)
+
+static char *data_buffer;
+
+/* Prototypes. */
+static void listing_message PARAMS ((const char *name, const char *message));
+static file_info_type *file_info PARAMS ((const char *file_name));
+static void new_frag PARAMS ((void));
+static char *buffer_line PARAMS ((file_info_type *file,
+ char *line, unsigned int size));
+static void listing_page PARAMS ((list_info_type *list));
+static unsigned int calc_hex PARAMS ((list_info_type *list));
+static void print_lines PARAMS ((list_info_type *, unsigned int,
+ char *, unsigned int));
+static void list_symbol_table PARAMS ((void));
+static void print_source PARAMS ((file_info_type *current_file,
+ list_info_type *list,
+ char *buffer,
+ unsigned int width));
+static int debugging_pseudo PARAMS ((list_info_type *, const char *));
+static void listing_listing PARAMS ((char *name));
-/* this static array is used to keep the text of data to be printed
- before the start of the line.
- It is stored so we can give a bit more info on the next line. To much, and large
- initialized arrays will use up lots of paper.
- */
-static char data_buffer[100];
-static unsigned int data_buffer_size;
-
-
static void
-DEFUN(listing_message,(name, message),
- char *name AND
- char *message)
+listing_message (name, message)
+ const char *name;
+ const char *message;
{
- unsigned int l = strlen(name) + strlen(message)+1;
- char *n = (char*)malloc(l);
- strcpy(n,name);
- strcat(n,message);
- if(listing_tail != (list_info_type *)NULL)
- {
- listing_tail->message = n;
- }
-
+ unsigned int l = strlen (name) + strlen (message) + 1;
+ char *n = (char *) xmalloc (l);
+ strcpy (n, name);
+ strcat (n, message);
+ if (listing_tail != (list_info_type *) NULL)
+ {
+ listing_tail->message = n;
+ }
}
-
-
-
-void
-DEFUN(listing_warning,(message),
- char *message)
+void
+listing_warning (message)
+ const char *message;
{
- listing_message("Warning:", message);
+ listing_message ("Warning:", message);
}
-void
-DEFUN(listing_error,(message),
- char *message)
+void
+listing_error (message)
+ const char *message;
{
- listing_message("Error:", message);
+ listing_message ("Error:", message);
}
+int listing_lhs_width = LISTING_LHS_WIDTH;
+int listing_lhs_width_second = LISTING_LHS_WIDTH_SECOND;
+int listing_lhs_cont_lines = LISTING_LHS_CONT_LINES;
+int listing_rhs_width = LISTING_RHS_WIDTH;
static file_info_type *file_info_head;
+static file_info_type *last_open_file_info;
+static FILE *last_open_file;
static file_info_type *
-DEFUN(file_info, (file_name),
- char *file_name)
+file_info (file_name)
+ const char *file_name;
{
/* Find an entry with this file name */
file_info_type *p = file_info_head;
-
- while (p != (file_info_type *)NULL)
- {
- if (strcmp(p->filename, file_name) == 0)
- return p;
- p = p->next;
- }
+
+ while (p != (file_info_type *) NULL)
+ {
+ if (strcmp (p->filename, file_name) == 0)
+ return p;
+ p = p->next;
+ }
/* Make new entry */
- p = (file_info_type *)xmalloc(sizeof(file_info_type));
+ p = (file_info_type *) xmalloc (sizeof (file_info_type));
p->next = file_info_head;
file_info_head = p;
- p->filename = xmalloc(strlen(file_name)+1);
- strcpy(p->filename, file_name);
+ p->filename = xmalloc ((unsigned long) strlen (file_name) + 1);
+ strcpy (p->filename, file_name);
+ p->pos = 0;
p->linenum = 0;
- p->end_pending = 0;
-
- p->file = fopen(p->filename,"rb");
-if (p->file) fgetc(p->file);
-
-
+ p->at_end = 0;
return p;
-
}
-static void
-DEFUN_VOID(new_frag)
+static void
+new_frag ()
{
-
- frag_wane(frag_now);
- frag_new(0);
+
+ frag_wane (frag_now);
+ frag_new (0);
}
-void
-DEFUN(listing_newline,(ps),
- char *ps)
-{
- char *s = ps;
- extern char *file_name;
- static unsigned int last_line =0xffff ;
-
-
- list_info_type *new;
- if (physical_input_line != last_line)
- {
- last_line = physical_input_line;
- new_frag();
-
- new = (list_info_type *)malloc(sizeof(list_info_type));
- new->frag = frag_now;
- new->line = physical_input_line ;
- new->file = file_info(file_name);
-
- if (listing_tail)
+void
+listing_newline (ps)
+ char *ps;
+{
+ char *file;
+ unsigned int line;
+ static unsigned int last_line = 0xffff;
+ static char *last_file = NULL;
+ list_info_type *new = NULL;
+
+ if (listing == 0)
+ return;
+
+ if (now_seg == absolute_section)
+ return;
+
+#ifdef OBJ_ELF
+ /* In ELF, anything in a section beginning with .debug or .line is
+ considered to be debugging information. This includes the
+ statement which switches us into the debugging section, which we
+ can only set after we are already in the debugging section. */
+ if ((listing & LISTING_NODEBUG) != 0
+ && listing_tail != NULL
+ && ! listing_tail->debugging)
+ {
+ const char *segname;
+
+ segname = segment_name (now_seg);
+ if (strncmp (segname, ".debug", sizeof ".debug" - 1) == 0
+ || strncmp (segname, ".line", sizeof ".line" - 1) == 0)
+ listing_tail->debugging = 1;
+ }
+#endif
+
+ as_where (&file, &line);
+ if (ps == NULL)
+ {
+ if (line == last_line && !(last_file && file && strcmp(file, last_file)))
+ return;
+
+ new = (list_info_type *) xmalloc (sizeof (list_info_type));
+ new->line_contents = NULL;
+ }
+ else
+ {
+ new = (list_info_type *) xmalloc (sizeof (list_info_type));
+ new->line_contents = ps;
+ }
+
+ last_line = line;
+ last_file = file;
+ new_frag ();
+
+ if (listing_tail)
{
listing_tail->next = new;
}
- else
+ else
{
head = new;
}
- listing_tail = new;
- new->next = (list_info_type *)NULL;
- new->message = (char *)NULL;
- new->edict = EDICT_NONE;
- new->hll_file = (file_info_type*)NULL;
- new->hll_line = 0;
- new_frag();
- }
+ listing_tail = new;
+
+ new->frag = frag_now;
+ new->line = line;
+ new->file = file_info (file);
+ new->next = (list_info_type *) NULL;
+ new->message = (char *) NULL;
+ new->edict = EDICT_NONE;
+ new->hll_file = (file_info_type *) NULL;
+ new->hll_line = 0;
+ new->debugging = 0;
+ new_frag ();
+
+#ifdef OBJ_ELF
+ /* In ELF, anything in a section beginning with .debug or .line is
+ considered to be debugging information. */
+ if ((listing & LISTING_NODEBUG) != 0)
+ {
+ const char *segname;
+
+ segname = segment_name (now_seg);
+ if (strncmp (segname, ".debug", sizeof ".debug" - 1) == 0
+ || strncmp (segname, ".line", sizeof ".line" - 1) == 0)
+ new->debugging = 1;
+ }
+#endif
}
+/* Attach all current frags to the previous line instead of the
+ current line. This is called by the MIPS backend when it discovers
+ that it needs to add some NOP instructions; the added NOP
+ instructions should go with the instruction that has the delay, not
+ with the new instruction. */
+
+void
+listing_prev_line ()
+{
+ list_info_type *l;
+ fragS *f;
+
+ if (head == (list_info_type *) NULL
+ || head == listing_tail)
+ return;
+
+ new_frag ();
+
+ for (l = head; l->next != listing_tail; l = l->next)
+ ;
+
+ for (f = frchain_now->frch_root; f != (fragS *) NULL; f = f->fr_next)
+ if (f->line == listing_tail)
+ f->line = l;
+
+ listing_tail->frag = frag_now;
+ new_frag ();
+}
-/*
+/*
This function returns the next source line from the file supplied,
truncated to size. It appends a fake line to the end of each input
file to make
*/
static char *
-DEFUN(buffer_line,(file, line, size),
- file_info_type *file AND
- char *line AND
- unsigned int size)
+buffer_line (file, line, size)
+ file_info_type * file;
+ char *line;
+ unsigned int size;
{
unsigned int count = 0;
int c;
-
+
char *p = line;
/* If we couldn't open the file, return an empty line */
- if (file->file == (FILE*)NULL)
- {
+ if (file->at_end)
return "";
- }
- if (file->end_pending == 10) {
- *p ++ = '\n';
- fseek(file->file, 0,0 );
- file->linenum = 0;
- file->end_pending = 0;
- }
- c = fgetc(file->file);
+ /* Check the cache and see if we last used this file. */
+ if (!last_open_file_info || file != last_open_file_info)
+ {
+ if (last_open_file)
+ {
+ last_open_file_info->pos = ftell (last_open_file);
+ fclose (last_open_file);
+ }
+
+ last_open_file_info = file;
+ last_open_file = fopen (file->filename, "r");
+ if (!last_open_file)
+ return "";
+
+ /* Seek to where we were last time this file was open. */
+ if (file->pos)
+ fseek(last_open_file, file->pos, SEEK_SET);
+ }
+
+ c = fgetc (last_open_file);
-
size -= 1; /* leave room for null */
- while (c != EOF && c != '\n')
- {
- if (count < size)
- *p++ = c;
- count++;
-
- c= fgetc(file->file);
-
- }
- if (c == EOF)
- {
- file->end_pending ++;
- *p++ = '.';
- *p++ = '.';
- *p++ = '.';
- }
- file->linenum++;
+ while (c != EOF && c != '\n')
+ {
+ if (count < size)
+ *p++ = c;
+ count++;
+
+ c = fgetc (last_open_file);
+
+ }
+ if (c == EOF)
+ {
+ file->at_end = 1;
+ *p++ = '.';
+ *p++ = '.';
+ *p++ = '.';
+ }
+ file->linenum++;
*p++ = 0;
return line;
}
-static char *fn;
+static const char *fn;
static unsigned int eject; /* Eject pending */
-static unsigned int page; /* Current page number */
-static char *title; /* current title */
+static unsigned int page; /* Current page number */
+static char *title; /* current title */
static char *subtitle; /* current subtitle */
-static unsigned int on_page; /* number of lines printed on current page */
+static unsigned int on_page; /* number of lines printed on current page */
static void
-DEFUN(listing_page,(list),
- list_info_type *list)
+listing_page (list)
+ list_info_type *list;
{
/* Grope around, see if we can see a title or subtitle edict coming up
soon (we look down 10 lines of the page and see if it's there)*/
- if ((eject || (on_page >= paper_height)) && paper_height != 0)
- {
- unsigned int c = 10;
- int had_title = 0;
- int had_subtitle = 0;
-
- page++;
-
- while (c != 0 && list)
+ if ((eject || (on_page >= paper_height)) && paper_height != 0)
{
- if (list->edict == EDICT_SBTTL && !had_subtitle)
- {
- had_subtitle = 1;
- subtitle = list->edict_arg;
- }
- if (list->edict == EDICT_TITLE && !had_title)
- {
- had_title = 1;
- title = list->edict_arg;
- }
- list = list->next;
- c--;
- }
-
+ unsigned int c = 10;
+ int had_title = 0;
+ int had_subtitle = 0;
- if (page > 1)
- {
- printf("\f");
+ page++;
+
+ while (c != 0 && list)
+ {
+ if (list->edict == EDICT_SBTTL && !had_subtitle)
+ {
+ had_subtitle = 1;
+ subtitle = list->edict_arg;
+ }
+ if (list->edict == EDICT_TITLE && !had_title)
+ {
+ had_title = 1;
+ title = list->edict_arg;
+ }
+ list = list->next;
+ c--;
+ }
+
+
+ if (page > 1)
+ {
+ fprintf (list_file, "\f");
+ }
+
+ fprintf (list_file, "%s %s \t\t\tpage %d\n", LISTING_HEADER, fn, page);
+ fprintf (list_file, "%s\n", title);
+ fprintf (list_file, "%s\n", subtitle);
+ on_page = 3;
+ eject = 0;
}
-
- printf("%s %s \t\t\tpage %d\n", LISTING_HEADER, fn, page);
- printf("%s\n", title);
- printf("%s\n", subtitle);
- on_page = 3;
- eject = 0;
- }
}
-static unsigned int
-DEFUN(calc_hex,(list),
- list_info_type *list)
+static unsigned int
+calc_hex (list)
+ list_info_type * list;
{
+ int data_buffer_size;
list_info_type *first = list;
- list_info_type *last = first;
- unsigned int address = ~0;
-
+ unsigned int address = (unsigned int) ~0;
fragS *frag;
fragS *frag_ptr;
-
- unsigned int byte_in_frag = 0;
-
- int anything = 0;
+ unsigned int byte_in_frag;
/* Find first frag which says it belongs to this line */
- frag = list->frag;
- while (frag && frag->line != list)
- frag = frag->fr_next;
+ frag = list->frag;
+ while (frag && frag->line != list)
+ frag = frag->fr_next;
frag_ptr = frag;
data_buffer_size = 0;
-
+
/* Dump all the frags which belong to this line */
- while (frag_ptr != (fragS *)NULL && frag_ptr->line == first)
- {
- /* Print as many bytes from the fixed part as is sensible */
- while(byte_in_frag < frag_ptr->fr_fix && data_buffer_size < sizeof(data_buffer)-10)
+ while (frag_ptr != (fragS *) NULL && frag_ptr->line == first)
{
- if (address == ~0)
- {
- address = frag_ptr->fr_address;
- }
-
- sprintf(data_buffer + data_buffer_size,
- "%02X",
- (frag_ptr->fr_literal[byte_in_frag]) & 0xff);
- data_buffer_size += 2;
- byte_in_frag++;
- }
- {
- unsigned int var_rep_max = byte_in_frag;
- unsigned int var_rep_idx = byte_in_frag;
-
- /* Print as many bytes from the variable part as is sensible */
- while (byte_in_frag < frag_ptr->fr_var * frag_ptr->fr_offset
- && data_buffer_size < sizeof(data_buffer)-10)
- {
- if (address == ~0)
+ /* Print as many bytes from the fixed part as is sensible */
+ byte_in_frag = 0;
+ while (byte_in_frag < frag_ptr->fr_fix
+ && data_buffer_size < MAX_BYTES - 3)
+ {
+ if (address == ~0)
+ {
+ address = frag_ptr->fr_address;
+ }
+
+ sprintf (data_buffer + data_buffer_size,
+ "%02X",
+ (frag_ptr->fr_literal[byte_in_frag]) & 0xff);
+ data_buffer_size += 2;
+ byte_in_frag++;
+ }
{
- address = frag_ptr->fr_address;
- }
-sprintf(data_buffer + data_buffer_size,
- "%02X",
- (frag_ptr->fr_literal[var_rep_idx]) & 0xff);
-#if 0
- data_buffer[data_buffer_size++] = '*';
- data_buffer[data_buffer_size++] = '*';
+ unsigned int var_rep_max = byte_in_frag;
+ unsigned int var_rep_idx = byte_in_frag;
+
+ /* Print as many bytes from the variable part as is sensible */
+ while ((byte_in_frag
+ < frag_ptr->fr_fix + frag_ptr->fr_var * frag_ptr->fr_offset)
+ && data_buffer_size < MAX_BYTES - 3)
+ {
+ if (address == ~0)
+ {
+ address = frag_ptr->fr_address;
+ }
+ sprintf (data_buffer + data_buffer_size,
+ "%02X",
+ (frag_ptr->fr_literal[var_rep_idx]) & 0xff);
+#if 0
+ data_buffer[data_buffer_size++] = '*';
+ data_buffer[data_buffer_size++] = '*';
#endif
- data_buffer_size +=2;
-
- var_rep_idx ++;
- byte_in_frag++;
-
- if (var_rep_idx >= frag_ptr->fr_var)
- var_rep_idx = var_rep_max;
- }
- }
-
- frag_ptr = frag_ptr->fr_next;
- }
- data_buffer[data_buffer_size++] = 0;
+ data_buffer_size += 2;
+
+ var_rep_idx++;
+ byte_in_frag++;
+
+ if (var_rep_idx >= frag_ptr->fr_fix + frag_ptr->fr_var)
+ var_rep_idx = var_rep_max;
+ }
+ }
+
+ frag_ptr = frag_ptr->fr_next;
+ }
+ data_buffer[data_buffer_size] = '\0';
return address;
}
static void
-DEFUN(print_lines,(list, string, address),
-list_info_type *list AND
-char *string AND
-unsigned int address)
+print_lines (list, lineno, string, address)
+ list_info_type *list;
+ unsigned int lineno;
+ char *string;
+ unsigned int address;
{
unsigned int idx;
unsigned int nchars;
unsigned int lines;
- unsigned int byte_in_word =0;
+ unsigned int byte_in_word = 0;
char *src = data_buffer;
-
+
/* Print the stuff on the first line */
- listing_page(list);
- nchars = (LISTING_WORD_SIZE*2 +1) * LISTING_LHS_WIDTH ;
+ listing_page (list);
+ nchars = (LISTING_WORD_SIZE * 2 + 1) * listing_lhs_width;
/* Print the hex for the first line */
- if (address == ~0)
- {
- printf("% 4d ", list->line);
- for (idx = 0; idx < nchars; idx++)
- printf(" ");
-
- printf("\t%s\n", string ? string : "");
- on_page++;
- listing_page(0);
-
- }
- else
- {
- if (had_errors())
- {
- printf("% 4d ???? ", list->line);
- }
- else
- {
- printf("% 4d %04x ", list->line, address);
- }
-
- /* And the data to go along with it */
- idx = 0;
-
- while (*src && idx < nchars)
- {
- printf("%c%c", src[0], src[1]);
- src += 2;
- byte_in_word++;
- if (byte_in_word == LISTING_WORD_SIZE)
- {
- printf(" ");
- idx++;
- byte_in_word = 0;
- }
- idx+=2;
- }
-
- for (;idx < nchars; idx++)
- printf(" ");
-
- printf("\t%s\n", string ? string : "");
- on_page++;
- listing_page(list);
- if (list->message)
- {
- printf("**** %s\n",list->message);
- listing_page(list);
+ if (address == ~0)
+ {
+ fprintf (list_file, "% 4d ", lineno);
+ for (idx = 0; idx < nchars; idx++)
+ fprintf (list_file, " ");
+
+ fprintf (list_file, "\t%s\n", string ? string : "");
on_page++;
+ listing_page (0);
+
}
+ else
+ {
+ if (had_errors ())
+ {
+ fprintf (list_file, "% 4d ???? ", lineno);
+ }
+ else
+ {
+ fprintf (list_file, "% 4d %04x ", lineno, address);
+ }
+
+ /* And the data to go along with it */
+ idx = 0;
- for (lines = 0;
- lines < LISTING_LHS_CONT_LINES
- && *src;
- lines++) {
- nchars = ((LISTING_WORD_SIZE*2) +1) * LISTING_LHS_WIDTH_SECOND -1;
- idx = 0;
- /* Print any more lines of data, but more compactly */
- printf("% 4d ", list->line);
-
- while (*src && idx < nchars)
+ while (*src && idx < nchars)
{
- printf("%c%c", src[0], src[1]);
- src+=2;
- idx+=2;
+ fprintf (list_file, "%c%c", src[0], src[1]);
+ src += 2;
byte_in_word++;
- if (byte_in_word == LISTING_WORD_SIZE)
- {
- printf(" ");
- idx++;
- byte_in_word = 0;
- }
+ if (byte_in_word == LISTING_WORD_SIZE)
+ {
+ fprintf (list_file, " ");
+ idx++;
+ byte_in_word = 0;
+ }
+ idx += 2;
}
-
- printf("\n");
- on_page++;
- listing_page(list);
-
- }
-
- }
-}
+ for (; idx < nchars; idx++)
+ fprintf (list_file, " ");
+
+ fprintf (list_file, "\t%s\n", string ? string : "");
+ on_page++;
+ listing_page (list);
+ if (list->message)
+ {
+ fprintf (list_file, "**** %s\n", list->message);
+ listing_page (list);
+ on_page++;
+ }
-
-
-
+ for (lines = 0; lines < listing_lhs_cont_lines && *src; lines++)
+ {
+ nchars = (((LISTING_WORD_SIZE * 2) + 1)
+ * listing_lhs_width_second - 1);
+ idx = 0;
+ /* Print any more lines of data, but more compactly */
+ fprintf (list_file, "% 4d ", lineno);
+
+ while (*src && idx < nchars)
+ {
+ fprintf (list_file, "%c%c", src[0], src[1]);
+ src += 2;
+ idx += 2;
+ byte_in_word++;
+ if (byte_in_word == LISTING_WORD_SIZE)
+ {
+ fprintf (list_file, " ");
+ idx++;
+ byte_in_word = 0;
+ }
+ }
+
+ fprintf (list_file, "\n");
+ on_page++;
+ listing_page (list);
+
+ }
+
+
+ }
+}
static void
-DEFUN_VOID(list_symbol_table)
+list_symbol_table ()
{
extern symbolS *symbol_rootP;
-
- symbolS *ptr ;
+ int got_some = 0;
+
+ symbolS *ptr;
eject = 1;
- listing_page(0);
- printf("DEFINED SYMBOLS\n");
- on_page++;
-
- for (ptr = symbol_rootP; ptr != (symbolS*)NULL; ptr = symbol_next(ptr))
- {
- if (ptr->sy_frag->line)
+ listing_page (0);
+
+ for (ptr = symbol_rootP; ptr != (symbolS *) NULL; ptr = symbol_next (ptr))
{
- if (S_GET_NAME(ptr))
- {
-
- if (strlen(S_GET_NAME(ptr)))
- {
- printf("%20s:%-5d %2d:%08x %s \n",
- ptr->sy_frag->line->file->filename,
- ptr->sy_frag->line->line,
- S_GET_SEGMENT(ptr),
- S_GET_VALUE(ptr),
- S_GET_NAME(ptr));
- }
-
- else
- {
- printf("%20s:%-5d %2d:%08x\n",
- ptr->sy_frag->line->file->filename,
- ptr->sy_frag->line->line,
- S_GET_SEGMENT(ptr),
- S_GET_VALUE(ptr));
-
+ if (ptr->sy_frag->line)
+ {
+ if (S_GET_NAME (ptr))
+ {
+ char buf[30], fmt[8];
+ valueT val = S_GET_VALUE (ptr);
+
+ /* @@ Note that this is dependent on the compilation options,
+ not solely on the target characteristics. */
+ if (sizeof (val) == 4 && sizeof (int) == 4)
+ sprintf (buf, "%08lx", (unsigned long) val);
+ else if (sizeof (val) <= sizeof (unsigned long))
+ {
+ sprintf (fmt, "%%0%lulx",
+ (unsigned long) (sizeof (val) * 2));
+ sprintf (buf, fmt, (unsigned long) val);
+ }
+#if defined (BFD64)
+ else if (sizeof (val) > 4)
+ sprintf_vma (buf, val);
+#endif
+ else
+ abort ();
+
+ if (!got_some)
+ {
+ fprintf (list_file, "DEFINED SYMBOLS\n");
+ on_page++;
+ got_some = 1;
+ }
+
+ fprintf (list_file, "%20s:%-5d %s:%s %s\n",
+ ptr->sy_frag->line->file->filename,
+ ptr->sy_frag->line->line,
+ segment_name (S_GET_SEGMENT (ptr)),
+ buf, S_GET_NAME (ptr));
+
+ on_page++;
+ listing_page (0);
+ }
+ }
- }
-
- on_page++;
- listing_page(0);
- }
}
-
- }
- printf("\n");
- on_page++;
- listing_page(0);
- printf("UNDEFINED SYMBOLS\n");
+ if (!got_some)
+ {
+ fprintf (list_file, "NO DEFINED SYMBOLS\n");
+ on_page++;
+ }
+ fprintf (list_file, "\n");
on_page++;
- listing_page(0);
-
- for (ptr = symbol_rootP; ptr != (symbolS*)NULL; ptr = symbol_next(ptr))
- {
- if (S_GET_NAME(ptr) && strlen(S_GET_NAME(ptr)) != 0)
+ listing_page (0);
+
+ got_some = 0;
+
+ for (ptr = symbol_rootP; ptr != (symbolS *) NULL; ptr = symbol_next (ptr))
{
- if (ptr->sy_frag->line == 0)
- {
- printf("%s\n", S_GET_NAME(ptr));
- on_page++;
- listing_page(0);
- }
+ if (S_GET_NAME (ptr) && strlen (S_GET_NAME (ptr)) != 0)
+ {
+ if (ptr->sy_frag->line == 0
+#ifdef S_IS_REGISTER
+ && !S_IS_REGISTER (ptr)
+#endif
+ && S_GET_SEGMENT (ptr) != reg_section)
+ {
+ if (!got_some)
+ {
+ got_some = 1;
+ fprintf (list_file, "UNDEFINED SYMBOLS\n");
+ on_page++;
+ listing_page (0);
+ }
+ fprintf (list_file, "%s\n", S_GET_NAME (ptr));
+ on_page++;
+ listing_page (0);
+ }
+ }
+ }
+ if (!got_some)
+ {
+ fprintf (list_file, "NO UNDEFINED SYMBOLS\n");
+ on_page++;
+ listing_page (0);
}
- }
}
-void
-DEFUN(print_source,(current_file, list, buffer, width),
- file_info_type *current_file AND
- list_info_type *list AND
- char *buffer AND
- unsigned int width)
-{
- if (current_file->file) {
- while (current_file->linenum < list->hll_line)
- {
- char * p = buffer_line(current_file, buffer, width);
- printf("%4d:%-13s **** %s\n", current_file->linenum, current_file->filename, p);
- on_page++;
- listing_page(list);
- }
+static void
+print_source (current_file, list, buffer, width)
+ file_info_type *current_file;
+ list_info_type *list;
+ char *buffer;
+ unsigned int width;
+{
+ if (!current_file->at_end)
+ {
+ while (current_file->linenum < list->hll_line
+ && !current_file->at_end)
+ {
+ char *p = buffer_line (current_file, buffer, width);
+ fprintf (list_file, "%4d:%-13s **** %s\n", current_file->linenum,
+ current_file->filename, p);
+ on_page++;
+ listing_page (list);
+ }
}
}
/* Sometimes the user doesn't want to be bothered by the debugging
- records inserted by the compiler, see if the line is suspicioous */
+ records inserted by the compiler, see if the line is suspicious. */
static int
-DEFUN(debugging_pseudo,(line),
- char *line)
+debugging_pseudo (list, line)
+ list_info_type *list;
+ const char *line;
{
- while (isspace(*line))
- line++;
+ static int in_debug;
+ int was_debug;
+
+ if (list->debugging)
+ {
+ in_debug = 1;
+ return 1;
+ }
+
+ was_debug = in_debug;
+ in_debug = 0;
+
+ while (isspace (*line))
+ line++;
+
+ if (*line != '.')
+ {
+#ifdef OBJ_ELF
+ /* The ELF compiler sometimes emits blank lines after switching
+ out of a debugging section. If the next line drops us back
+ into debugging information, then don't print the blank line.
+ This is a hack for a particular compiler behaviour, not a
+ general case. */
+ if (was_debug
+ && *line == '\0'
+ && list->next != NULL
+ && list->next->debugging)
+ {
+ in_debug = 1;
+ return 1;
+ }
+#endif
+
+ return 0;
+ }
- if(*line != '.') return 0;
-
line++;
- if (strncmp(line, "def",3) == 0) return 1;
- if (strncmp(line, "val",3) == 0) return 1;
- if (strncmp(line, "scl",3) == 0) return 1;
- if (strncmp(line, "line",4) == 0) return 1;
- if (strncmp(line, "endef",5) == 0) return 1;
- if (strncmp(line, "ln",2) ==0) return 1;
- if (strncmp(line, "type",4) ==0) return 1;
- if (strncmp(line, "size",4) == 0) return 1;
- if (strncmp(line, "dim",3) ==0) return 1;
- if (strncmp(line, "tag",3) == 0) return 1;
-
- return 0;
+ if (strncmp (line, "def", 3) == 0)
+ return 1;
+ if (strncmp (line, "val", 3) == 0)
+ return 1;
+ if (strncmp (line, "scl", 3) == 0)
+ return 1;
+ if (strncmp (line, "line", 4) == 0)
+ return 1;
+ if (strncmp (line, "endef", 5) == 0)
+ return 1;
+ if (strncmp (line, "ln", 2) == 0)
+ return 1;
+ if (strncmp (line, "type", 4) == 0)
+ return 1;
+ if (strncmp (line, "size", 4) == 0)
+ return 1;
+ if (strncmp (line, "dim", 3) == 0)
+ return 1;
+ if (strncmp (line, "tag", 3) == 0)
+ return 1;
+
+ if (strncmp (line, "stabs", 5) == 0)
+ return 1;
+ if (strncmp (line, "stabn", 5) == 0)
+ return 1;
+ return 0;
}
-void
-DEFUN(listing_listing,(name),
- char *name)
+static void
+listing_listing (name)
+ char *name;
{
list_info_type *list = head;
- file_info_type *current_hll_file = (file_info_type *)NULL;
-
- unsigned int page= 1;
- unsigned int prev = 0;
+ file_info_type *current_hll_file = (file_info_type *) NULL;
char *message;
char *buffer;
char *p;
- unsigned int addr = 0;
- int on_page = 0;
int show_listing = 1;
unsigned int width;
-
- buffer = malloc(LISTING_RHS_WIDTH);
+
+ buffer = xmalloc (listing_rhs_width);
+ data_buffer = xmalloc (MAX_BYTES);
eject = 1;
list = head;
- while (list != (list_info_type *)NULL && 0)
- {
- if (list->next)
- list->frag = list->next->frag;
- list = list->next;
+ while (list != (list_info_type *) NULL && 0)
+ {
+ if (list->next)
+ list->frag = list->next->frag;
+ list = list->next;
+
+ }
- }
-
list = head->next;
- while ( list)
- {
- width = LISTING_RHS_WIDTH > paper_width ? paper_width :
- LISTING_RHS_WIDTH;
-
- switch (list->edict) {
- case EDICT_LIST:
- show_listing++;
- break;
- case EDICT_NOLIST:
- show_listing--;
- break;
- case EDICT_EJECT:
- break;
- case EDICT_NONE:
- break;
- case EDICT_TITLE:
- title = list->edict_arg;
- break;
- case EDICT_SBTTL:
- subtitle = list->edict_arg;
- break;
- default:
- abort();
- }
-
- if (show_listing > 0)
+ while (list)
{
- /* Scan down the list and print all the stuff which can be done
- with this line (or lines) */
- message = 0;
+ width = listing_rhs_width > paper_width ? paper_width :
+ listing_rhs_width;
- if (list->hll_file)
- {
- current_hll_file = list->hll_file;
- }
+ switch (list->edict)
+ {
+ case EDICT_LIST:
+ show_listing++;
+ break;
+ case EDICT_NOLIST:
+ show_listing--;
+ break;
+ case EDICT_NOLIST_NEXT:
+ break;
+ case EDICT_EJECT:
+ break;
+ case EDICT_NONE:
+ break;
+ case EDICT_TITLE:
+ title = list->edict_arg;
+ break;
+ case EDICT_SBTTL:
+ subtitle = list->edict_arg;
+ break;
+ default:
+ abort ();
+ }
- if (current_hll_file && list->hll_line && listing & LISTING_HLL)
- {
- print_source(current_hll_file, list, buffer, width);
- }
-
- p = buffer_line(list->file, buffer, width);
+ if (show_listing > 0)
+ {
+ /* Scan down the list and print all the stuff which can be done
+ with this line (or lines). */
+ message = 0;
+
+ if (list->hll_file)
+ {
+ current_hll_file = list->hll_file;
+ }
+
+ if (current_hll_file && list->hll_line && (listing & LISTING_HLL))
+ {
+ print_source (current_hll_file, list, buffer, width);
+ }
+
+ if (list->line_contents)
+ {
+ if (!((listing & LISTING_NODEBUG)
+ && debugging_pseudo (list, list->line_contents)))
+ {
+ print_lines (list, list->file->linenum,
+ list->line_contents, calc_hex (list));
+ }
+ }
+ else
+ {
+ while (list->file->linenum < list->line
+ && !list->file->at_end)
+ {
+ unsigned int address;
+
+ p = buffer_line (list->file, buffer, width);
+
+ if (list->file->linenum < list->line)
+ address = ~ (unsigned int) 0;
+ else
+ address = calc_hex (list);
+
+ if (!((listing & LISTING_NODEBUG)
+ && debugging_pseudo (list, p)))
+ print_lines (list, list->file->linenum, p, address);
+ }
+ }
+
+ if (list->edict == EDICT_EJECT)
+ {
+ eject = 1;
+ }
+ }
+ else
+ {
+ while (list->file->linenum < list->line
+ && !list->file->at_end)
+ p = buffer_line (list->file, buffer, width);
+ }
- if (! ((listing & LISTING_NODEBUG) && debugging_pseudo(p)))
- {
- print_lines(list, p, calc_hex(list));
- }
+ if (list->edict == EDICT_NOLIST_NEXT)
+ --show_listing;
- if (list->edict == EDICT_EJECT)
- {
- eject = 1;
- }
- }
- else
- {
-
- p = buffer_line(list->file, buffer, width);
+ list = list->next;
}
-
- list = list->next;
- }
- free(buffer);
+
+ free (buffer);
+ free (data_buffer);
+ data_buffer = NULL;
}
-void
-DEFUN(listing_print,(name),
- char *name)
+void
+listing_print (name)
+ char *name;
{
+ int using_stdout;
+ file_info_type *fi;
+
title = "";
- subtitle = "";
-
- if (listing & LISTING_NOFORM)
- {
- paper_height = 0;
- }
-
- if (listing & LISTING_LISTING)
- {
- listing_listing(name);
-
- }
- if (listing & LISTING_SYMBOLS)
- {
- list_symbol_table();
- }
-}
+ subtitle = "";
+
+ if (name == NULL)
+ {
+ list_file = stdout;
+ using_stdout = 1;
+ }
+ else
+ {
+ list_file = fopen (name, "w");
+ if (list_file != NULL)
+ using_stdout = 0;
+ else
+ {
+ as_perror ("can't open list file: %s", name);
+ list_file = stdout;
+ using_stdout = 1;
+ }
+ }
+
+ if (listing & LISTING_NOFORM)
+ {
+ paper_height = 0;
+ }
+
+ if (listing & LISTING_LISTING)
+ {
+ listing_listing (name);
+ }
+
+ if (listing & LISTING_SYMBOLS)
+ {
+ list_symbol_table ();
+ }
+
+ if (! using_stdout)
+ {
+ if (fclose (list_file) == EOF)
+ as_perror ("error closing list file: %s", name);
+ }
+
+ if (last_open_file)
+ {
+ fclose (last_open_file);
+ }
+}
void
-DEFUN(listing_file,(name),
-char *name)
+listing_file (name)
+ const char *name;
{
- fn = name;
+ fn = name;
}
-void
-DEFUN_VOID(listing_eject)
+void
+listing_eject (ignore)
+ int ignore;
{
- listing_tail->edict = EDICT_EJECT;
+ if (listing)
+ listing_tail->edict = EDICT_EJECT;
}
void
-DEFUN_VOID(listing_flags)
+listing_flags (ignore)
+ int ignore;
{
-
+ while ((*input_line_pointer++) && (*input_line_pointer != '\n'))
+ input_line_pointer++;
+
}
+
+/* Turn listing on or off. An argument of 0 means to turn off
+ listing. An argument of 1 means to turn on listing. An argument
+ of 2 means to turn off listing, but as of the next line; that is,
+ the current line should be listed, but the next line should not. */
+
void
-DEFUN(listing_list,(on),
- unsigned int on)
+listing_list (on)
+ int on;
{
- listing_tail->edict = on ? EDICT_LIST : EDICT_NOLIST;
+ if (listing)
+ {
+ switch (on)
+ {
+ case 0:
+ if (listing_tail->edict == EDICT_LIST)
+ listing_tail->edict = EDICT_NONE;
+ else
+ listing_tail->edict = EDICT_NOLIST;
+ break;
+ case 1:
+ if (listing_tail->edict == EDICT_NOLIST
+ || listing_tail->edict == EDICT_NOLIST_NEXT)
+ listing_tail->edict = EDICT_NONE;
+ else
+ listing_tail->edict = EDICT_LIST;
+ break;
+ case 2:
+ listing_tail->edict = EDICT_NOLIST_NEXT;
+ break;
+ default:
+ abort ();
+ }
+ }
}
void
-DEFUN_VOID(listing_psize)
+listing_psize (width_only)
+ int width_only;
{
- paper_height = get_absolute_expression();
+ if (! width_only)
+ {
+ paper_height = get_absolute_expression ();
- if (paper_height < 0 || paper_height > 1000)
- {
- paper_height = 0;
- as_warn("strange paper height, set to no form");
- }
- if (*input_line_pointer == ',')
- {
- input_line_pointer++;
- paper_width = get_absolute_expression();
- }
+ if (paper_height < 0 || paper_height > 1000)
+ {
+ paper_height = 0;
+ as_warn ("strange paper height, set to no form");
+ }
+
+ if (*input_line_pointer != ',')
+ {
+ demand_empty_rest_of_line ();
+ return;
+ }
+
+ ++input_line_pointer;
+ }
+
+ paper_width = get_absolute_expression ();
+
+ demand_empty_rest_of_line ();
}
+void
+listing_nopage (ignore)
+ int ignore;
+{
+ paper_height = 0;
+}
void
-DEFUN(listing_title,(depth),
- unsigned int depth)
+listing_title (depth)
+ int depth;
{
+ int quoted;
char *start;
- char *title;
+ char *ttl;
unsigned int length;
-
- SKIP_WHITESPACE();
- if (*input_line_pointer=='\"') {
- input_line_pointer++;
- start = input_line_pointer;
-
- while (*input_line_pointer)
- {
- if (*input_line_pointer == '\"')
+
+ SKIP_WHITESPACE ();
+ if (*input_line_pointer != '\"')
+ quoted = 0;
+ else
+ {
+ quoted = 1;
+ ++input_line_pointer;
+ }
+
+ start = input_line_pointer;
+
+ while (*input_line_pointer)
+ {
+ if (quoted
+ ? *input_line_pointer == '\"'
+ : is_end_of_line[(unsigned char) *input_line_pointer])
{
- length = input_line_pointer - start;
- title = malloc(length + 1);
- memcpy(title, start, length);
- title[length] = 0;
- listing_tail->edict = depth ? EDICT_SBTTL : EDICT_TITLE;
- listing_tail->edict_arg = title;
- input_line_pointer++;
- demand_empty_rest_of_line();
- return;
+ if (listing)
+ {
+ length = input_line_pointer - start;
+ ttl = xmalloc (length + 1);
+ memcpy (ttl, start, length);
+ ttl[length] = 0;
+ listing_tail->edict = depth ? EDICT_SBTTL : EDICT_TITLE;
+ listing_tail->edict_arg = ttl;
+ }
+ if (quoted)
+ input_line_pointer++;
+ demand_empty_rest_of_line ();
+ return;
}
- else if (*input_line_pointer == '\n')
+ else if (*input_line_pointer == '\n')
{
- as_bad("New line in title");
- demand_empty_rest_of_line();
+ as_bad ("New line in title");
+ demand_empty_rest_of_line ();
return;
}
- else
+ else
{
input_line_pointer++;
}
- }
}
- else
- {
- as_bad("expecting title in quotes");
- }
}
void
-DEFUN(listing_source_line,(line),
- unsigned int line)
+listing_source_line (line)
+ unsigned int line;
{
- new_frag();
- listing_tail->hll_line = line;
- new_frag();
-
+ if (listing)
+ {
+ new_frag ();
+ listing_tail->hll_line = line;
+ new_frag ();
+ }
}
void
-DEFUN(listing_source_file,(file),
- char *file)
+listing_source_file (file)
+ const char *file;
{
- listing_tail->hll_file = file_info(file);
+ if (listing)
+ listing_tail->hll_file = file_info (file);
}
-
+
#else
/* Dummy functions for when compiled without listing enabled */
+void
+listing_flags (ignore)
+ int ignore;
+{
+ s_ignore (0);
+}
+
void
-DEFUN_VOID(listing_flags)
+listing_list (on)
+ int on;
{
- s_ignore();
+ s_ignore (0);
}
-void DEFUN_VOID(listing_list)
+void
+listing_eject (ignore)
+ int ignore;
{
- s_ignore();
+ s_ignore (0);
}
-void DEFUN_VOID(listing_eject)
+void
+listing_psize (ignore)
+ int ignore;
{
- s_ignore();
+ s_ignore (0);
}
-void DEFUN_VOID(listing_psize)
+
+void
+listing_nopage (ignore)
+ int ignore;
{
- s_ignore();
+ s_ignore (0);
}
-void DEFUN(listing_title, (depth),
-unsigned int depth)
+void
+listing_title (depth)
+ int depth;
{
- s_ignore();
+ s_ignore (0);
}
+
void
-DEFUN(listing_file,(name),
-char *name)
+listing_file (name)
+ const char *name;
{
}
-void DEFUN(listing_newline,(name),
-char *name)
+void
+listing_newline (name)
+ char *name;
{
-
+
}
-void DEFUN(listing_source_line,(n),
-unsigned int n)
+void
+listing_source_line (n)
+ unsigned int n;
{
-
+
}
-void DEFUN(listing_source_file, (n),
-char *n)
+void
+listing_source_file (n)
+ const char *n;
{
-
-}
-
+}
#endif
-