X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gas%2Flisting.c;h=359dc090dc0df6115bfebae0b63eb6a1827aca03;hb=bb1183e25ae74ba21500fb4e39bc1ca9822e3086;hp=e2b173be7d68be23142b6fa0a1d726b60d4f2c62;hpb=252b5132c753830d5fd56823373aed85f2a0db63;p=deliverable%2Fbinutils-gdb.git diff --git a/gas/listing.c b/gas/listing.c index e2b173be7d..359dc090dc 100644 --- a/gas/listing.c +++ b/gas/listing.c @@ -1,28 +1,24 @@ -/* listing.c - mainting assembly listings - Copyright (C) 1991, 92, 93, 94, 95, 96, 97, 98, 1999 - Free Software Foundation, Inc. +/* listing.c - maintain assembly listings + Copyright (C) 1991-2020 Free Software Foundation, Inc. -This file is part of GAS, the GNU Assembler. + This file is part of GAS, the GNU Assembler. -GAS is free software; you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation; either version 2, or (at your option) -any later version. + GAS is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3, or (at your option) + any later version. -GAS is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. + GAS is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + 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, 59 Temple Place - Suite 330, Boston, MA -02111-1307, USA. */ - -/* - Contributed by Steve Chamberlain - sac@cygnus.com + 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, 51 Franklin Street - Fifth Floor, Boston, MA + 02110-1301, USA. */ +/* Contributed by Steve Chamberlain A listing page looks like: @@ -45,7 +41,7 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA will affect the page they are on, as well as any subsequent page .eject - Thow a page + Throw a page .list Increment the enable listing counter .nolist @@ -57,7 +53,6 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA If the counter goes below zero, listing is suppressed. - Listings are a maintained by read calling various listing_ functions. What happens most is that the macro NO_LISTING is not defined (from the Makefile), then the macro LISTING_NEWLINE expands @@ -67,7 +62,7 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA The function listing_newline remembers the frag associated with the newline, and creates a new frag - note that this is wasteful, but not a big deal, since listing slows things down a lot anyway. The - function also rememebers when the filename changes. + function also remembers when the filename changes. When all the input has finished, and gas has had a chance to settle down, the listing is output. This is done by running down the list of @@ -88,17 +83,18 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA LISTING_LHS_WIDTH_SECOND Number of words for the data on the lhs for the second line - LISTING_LHS_CONT_LINES Max number of lines to use up for a continutation + LISTING_LHS_CONT_LINES Max number of lines to use up for a continuation LISTING_RHS_WIDTH Number of chars from the input file to print - on a line -*/ - -#include + on a line. */ #include "as.h" -#include +#include "filenames.h" +#include "safe-ctype.h" #include "input-file.h" #include "subsegs.h" +#include "bfdver.h" +#include +#include #ifndef NO_LISTING @@ -109,10 +105,10 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA #define LISTING_WORD_SIZE 4 #endif #ifndef LISTING_LHS_WIDTH -#define LISTING_LHS_WIDTH 1 +#define LISTING_LHS_WIDTH ((LISTING_WORD_SIZE) > 4 ? 1 : 4 / (LISTING_WORD_SIZE)) #endif #ifndef LISTING_LHS_WIDTH_SECOND -#define LISTING_LHS_WIDTH_SECOND 1 +#define LISTING_LHS_WIDTH_SECOND LISTING_LHS_WIDTH #endif #ifndef LISTING_RHS_WIDTH #define LISTING_RHS_WIDTH 100 @@ -120,8 +116,9 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA #ifndef LISTING_LHS_CONT_LINES #define LISTING_LHS_CONT_LINES 4 #endif +#define MAX_DATELEN 30 -/* This structure remembers which .s were used */ +/* This structure remembers which .s were used. */ typedef struct file_info_struct { struct file_info_struct * next; @@ -129,48 +126,58 @@ typedef struct file_info_struct long pos; unsigned int linenum; int at_end; -} -file_info_type; +} file_info_type; + +enum edict_enum +{ + EDICT_NONE, + EDICT_SBTTL, + EDICT_TITLE, + EDICT_NOLIST, + EDICT_LIST, + EDICT_NOLIST_NEXT, + EDICT_EJECT +}; + + +struct list_message +{ + char *message; + struct list_message *next; +}; -/* This structure rememebrs which line from which file goes into which - frag */ +/* This structure remembers which line from which file goes into which + frag. */ struct list_info_struct { - /* Frag which this line of source is nearest to */ - fragS * frag; + /* Frag which this line of source is nearest to. */ + fragS *frag; - /* The actual line in the source file */ + /* 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; + belongs to. */ + file_info_type *file; /* The expanded text of any macro that may have been executing. */ - char * line_contents; + char *line_contents; - /* Next in list */ - struct list_info_struct * next; + /* 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 */ + source line that belongs here. */ + file_info_type *hll_file; + + /* High level language source line. */ unsigned int hll_line; - /* Pointer to any error message associated with this line */ - char * message; + /* Pointers to linked list of messages associated with this line. */ + struct list_message *messages, *last_message; - enum - { - EDICT_NONE, - EDICT_SBTTL, - EDICT_TITLE, - EDICT_NOLIST, - EDICT_LIST, - EDICT_NOLIST_NEXT, - EDICT_EJECT - } edict; - char * edict_arg; + enum edict_enum edict; + char *edict_arg; /* Nonzero if this line is to be omitted because it contains debugging information. This can become a flags field if we come @@ -180,7 +187,6 @@ struct list_info_struct typedef struct list_info_struct list_info_type; - 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; @@ -198,7 +204,7 @@ static int paper_height = 60; extern int listing; /* File to output listings to. */ -static FILE * list_file; +static FILE *list_file; /* This static array is used to keep the text of data to be printed before the start of the line. */ @@ -209,77 +215,68 @@ static FILE * list_file; * listing_lhs_cont_lines) \ + 20) -static char * data_buffer; +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)); - +static void listing_message (const char *, const char *); +static file_info_type *file_info (const char *); +static void new_frag (void); +static void listing_page (list_info_type *); +static unsigned int calc_hex (list_info_type *); +static void print_lines (list_info_type *, unsigned int, const char *, + unsigned int); +static void list_symbol_table (void); +static int debugging_pseudo (list_info_type *, const char *); +static void listing_listing (char *); static void -listing_message (name, message) - const char *name; - const char *message; +listing_message (const char *name, const char *message) { - 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; + char *n = concat (name, message, (char *) NULL); + struct list_message *lm = XNEW (struct list_message); + lm->message = n; + lm->next = NULL; + + if (listing_tail->last_message) + listing_tail->last_message->next = lm; + else + listing_tail->messages = lm; + listing_tail->last_message = lm; } } void -listing_warning (message) - const char *message; +listing_warning (const char *message) { - listing_message (_("Warning:"), message); + listing_message (_("Warning: "), message); } void -listing_error (message) - const char *message; +listing_error (const char *message) { - listing_message (_("Error:"), message); + listing_message (_("Error: "), message); } static file_info_type * -file_info (file_name) - const char *file_name; +file_info (const char *file_name) { - /* Find an entry with this 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) + if (filename_cmp (p->filename, file_name) == 0) return p; p = p->next; } - /* Make new entry */ - - p = (file_info_type *) xmalloc (sizeof (file_info_type)); + /* Make new entry. */ + p = XNEW (file_info_type); p->next = file_info_head; file_info_head = p; - p->filename = xmalloc ((unsigned long) strlen (file_name) + 1); - strcpy (p->filename, file_name); + p->filename = xstrdup (file_name); p->pos = 0; p->linenum = 0; p->at_end = 0; @@ -287,25 +284,21 @@ file_info (file_name) return p; } - static void -new_frag () +new_frag (void) { - frag_wane (frag_now); frag_new (0); - } void -listing_newline (ps) - char *ps; +listing_newline (char *ps) { - char *file; + const char *file; unsigned int line; static unsigned int last_line = 0xffff; - static char *last_file = NULL; - list_info_type *new = NULL; + static const char *last_file = NULL; + list_info_type *new_i = NULL; if (listing == 0) return; @@ -331,13 +324,20 @@ listing_newline (ps) } #endif - as_where (&file, &line); + /* PR 21977 - use the physical file name not the logical one unless high + level source files are being included in the listing. */ + if (listing & LISTING_HLL) + file = as_where (&line); + else + file = as_where_physical (&line); + if (ps == NULL) { - if (line == last_line && !(last_file && file && strcmp (file, last_file))) + if (line == last_line + && !(last_file && file && filename_cmp (file, last_file))) return; - new = (list_info_type *) xmalloc (sizeof (list_info_type)); + new_i = XNEW (list_info_type); /* Detect if we are reading from stdin by examining the file name returned by as_where(). @@ -346,78 +346,83 @@ listing_newline (ps) same as the one used by input_scrub_new_file(), if that is not true, then this code will fail]. - If we are reading from stdin, then we need to save each input line - here (assuming of course that we actually have a line of input to read), - so that it can be displayed in the listing that is produced at the end - of the assembly. */ + If we are reading from stdin, then we need to save each input + line here (assuming of course that we actually have a line of + input to read), so that it can be displayed in the listing + that is produced at the end of the assembly. */ if (strcmp (file, _("{standard input}")) == 0 && input_line_pointer != NULL) { - char * copy; + char *copy, *src, *dest; int len; int seen_quote = 0; + int seen_slash = 0; - for (copy = input_line_pointer - 1; - * copy && (seen_quote - || (! is_end_of_line [(unsigned char) * copy])); - copy ++) - if (* copy == '"' && copy[-1] != '\\') - seen_quote = ! seen_quote; + for (copy = input_line_pointer; + *copy && (seen_quote + || is_end_of_line [(unsigned char) *copy] != 1); + copy++) + { + if (seen_slash) + seen_slash = 0; + else if (*copy == '\\') + seen_slash = 1; + else if (*copy == '"') + seen_quote = !seen_quote; + } - len = (copy - input_line_pointer) + 2; + len = copy - input_line_pointer + 1; - copy = xmalloc (len); + copy = XNEWVEC (char, len); - if (copy != NULL) + src = input_line_pointer; + dest = copy; + + while (--len) { - char * src = input_line_pointer - 1; - char * dest = copy; - - while (--len) - { - char c = * src ++; + unsigned char c = *src++; - /* Omit control characters in the listing. */ - if (isascii (c) && ! iscntrl (c)) - * dest ++ = c; - } - - *dest = 0; + /* Omit control characters in the listing. */ + if (!ISCNTRL (c)) + *dest++ = c; } - - new->line_contents = copy; + + *dest = 0; + + new_i->line_contents = copy; } else - new->line_contents = NULL; + new_i->line_contents = NULL; } else { - new = (list_info_type *) xmalloc (sizeof (list_info_type)); - new->line_contents = ps; + new_i = XNEW (list_info_type); + new_i->line_contents = ps; } last_line = line; last_file = file; - + new_frag (); if (listing_tail) - listing_tail->next = new; + listing_tail->next = new_i; else - head = new; - - 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; - + head = new_i; + + listing_tail = new_i; + + new_i->frag = frag_now; + new_i->line = line; + new_i->file = file_info (file); + new_i->next = (list_info_type *) NULL; + new_i->messages = NULL; + new_i->last_message = NULL; + new_i->edict = EDICT_NONE; + new_i->hll_file = (file_info_type *) NULL; + new_i->hll_line = 0; + new_i->debugging = 0; + new_frag (); #ifdef OBJ_ELF @@ -430,7 +435,7 @@ listing_newline (ps) segname = segment_name (now_seg); if (strncmp (segname, ".debug", sizeof ".debug" - 1) == 0 || strncmp (segname, ".line", sizeof ".line" - 1) == 0) - new->debugging = 1; + new_i->debugging = 1; } #endif } @@ -442,7 +447,7 @@ listing_newline (ps) with the new instruction. */ void -listing_prev_line () +listing_prev_line (void) { list_info_type *l; fragS *f; @@ -464,24 +469,18 @@ listing_prev_line () 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 * -buffer_line (file, line, size) - file_info_type * file; - char *line; - unsigned int size; +/* 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 using the returned buffer simpler. */ + +static const char * +buffer_line (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 we couldn't open the file, return an empty line. */ if (file->at_end) return ""; @@ -494,38 +493,55 @@ buffer_line (file, line, size) fclose (last_open_file); } + /* Open the file in the binary mode so that ftell above can + return a reliable value that we can feed to fseek below. */ last_open_file_info = file; - last_open_file = fopen (file->filename, "r"); + last_open_file = fopen (file->filename, FOPEN_RB); if (last_open_file == NULL) { file->at_end = 1; return ""; } - + /* Seek to where we were last time this file was open. */ if (file->pos) - fseek(last_open_file, file->pos, SEEK_SET); + fseek (last_open_file, file->pos, SEEK_SET); } - c = fgetc (last_open_file); + /* Leave room for null. */ + size -= 1; - size -= 1; /* leave room for null */ + c = fgetc (last_open_file); - while (c != EOF && c != '\n') + while (c != EOF && c != '\n' && c != '\r') { if (count < size) *p++ = c; count++; c = fgetc (last_open_file); + } + /* If '\r' is followed by '\n', swallow that. Likewise, if '\n' + is followed by '\r', swallow that as well. */ + if (c == '\r' || c == '\n') + { + int next = fgetc (last_open_file); + + if ((c == '\r' && next != '\n') + || (c == '\n' && next != '\r')) + ungetc (next, last_open_file); } + if (c == EOF) { file->at_end = 1; - *p++ = '.'; - *p++ = '.'; - *p++ = '.'; + if (count + 2 < size) + { + *p++ = '.'; + *p++ = '.'; + *p++ = '.'; + } } file->linenum++; *p++ = 0; @@ -533,22 +549,163 @@ buffer_line (file, line, size) } -static const char *fn; +/* This function rewinds the requested file back to the line requested, + reads it in again into the buffer provided and then restores the file + back to its original location. */ + +static void +rebuffer_line (file_info_type * file, + unsigned int linenum, + char * buffer, + unsigned int size) +{ + unsigned int count = 0; + unsigned int current_line; + char * p = buffer; + long pos; + long pos2; + int c; + bfd_boolean found = FALSE; + + /* Sanity checks. */ + if (file == NULL || buffer == NULL || size <= 1 || file->linenum <= linenum) + return; + + /* Check the cache and see if we last used this file. */ + if (last_open_file_info == NULL || file != last_open_file_info) + { + if (last_open_file) + { + last_open_file_info->pos = ftell (last_open_file); + fclose (last_open_file); + } + + /* Open the file in the binary mode so that ftell above can + return a reliable value that we can feed to fseek below. */ + last_open_file_info = file; + last_open_file = fopen (file->filename, FOPEN_RB); + if (last_open_file == NULL) + { + file->at_end = 1; + return; + } + + /* Seek to where we were last time this file was open. */ + if (file->pos) + fseek (last_open_file, file->pos, SEEK_SET); + } + + /* Remember where we are in the current file. */ + pos2 = pos = ftell (last_open_file); + if (pos < 3) + return; + current_line = file->linenum; + + /* Leave room for the nul at the end of the buffer. */ + size -= 1; + buffer[size] = 0; + + /* Increment the current line count by one. + This is to allow for the fact that we are searching for the + start of a previous line, but we do this by detecting end-of-line + character(s) not start-of-line characters. */ + ++ current_line; + + while (pos2 > 0 && ! found) + { + char * ptr; + + /* Move backwards through the file, looking for earlier lines. */ + pos2 = (long) size > pos2 ? 0 : pos2 - size; + fseek (last_open_file, pos2, SEEK_SET); + + /* Our caller has kindly provided us with a buffer, so we use it. */ + if (fread (buffer, 1, size, last_open_file) != size) + { + as_warn (_("unable to rebuffer file: %s\n"), file->filename); + return; + } + + for (ptr = buffer + size; ptr >= buffer; -- ptr) + { + if (*ptr == '\n') + { + -- current_line; + + if (current_line == linenum) + { + /* We have found the start of the line we seek. */ + found = TRUE; + + /* FIXME: We could skip the read-in-the-line code + below if we know that we already have the whole + line in the buffer. */ + + /* Advance pos2 to the newline character we have just located. */ + pos2 += (ptr - buffer); + + /* Skip the newline and, if present, the carriage return. */ + if (ptr + 1 == buffer + size) + { + ++pos2; + if (fgetc (last_open_file) == '\r') + ++ pos2; + } + else + pos2 += (ptr[1] == '\r' ? 2 : 1); + + /* Move the file pointer to this location. */ + fseek (last_open_file, pos2, SEEK_SET); + break; + } + } + } + } + + /* Read in the line. */ + c = fgetc (last_open_file); + + while (c != EOF && c != '\n' && c != '\r') + { + if (count < size) + *p++ = c; + count++; -static unsigned int eject; /* Eject pending */ -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 */ + c = fgetc (last_open_file); + } + + /* If '\r' is followed by '\n', swallow that. Likewise, if '\n' + is followed by '\r', swallow that as well. */ + if (c == '\r' || c == '\n') + { + int next = fgetc (last_open_file); + + if ((c == '\r' && next != '\n') + || (c == '\n' && next != '\r')) + ungetc (next, last_open_file); + } + + /* Terminate the line. */ + *p++ = 0; + + /* Reset the file position. */ + fseek (last_open_file, pos, SEEK_SET); +} +static const char *fn; +static unsigned int eject; /* Eject pending. */ +static unsigned int page; /* Current page number. */ +static const char *title; /* Current title. */ +static const char *subtitle; /* Current subtitle. */ +static unsigned int on_page; /* Number of lines printed on current page. */ static void -listing_page (list) - list_info_type *list; +listing_page (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 >= (unsigned int) paper_height)) && paper_height != 0) + soon. (we look down 10 lines of the page and see if it's there) */ + if ((eject || (on_page >= (unsigned int) paper_height)) + && paper_height != 0) { unsigned int c = 10; int had_title = 0; @@ -572,7 +729,6 @@ listing_page (list) c--; } - if (page > 1) { fprintf (list_file, "\f"); @@ -586,19 +742,34 @@ listing_page (list) } } +/* Print a line into the list_file. Update the line count + and if necessary start a new page. */ + +static void +emit_line (list_info_type * list, const char * format, ...) +{ + va_list args; + + va_start (args, format); + + vfprintf (list_file, format, args); + on_page++; + listing_page (list); + + va_end (args); +} static unsigned int -calc_hex (list) - list_info_type * list; +calc_hex (list_info_type *list) { int data_buffer_size; list_info_type *first = list; - unsigned int address = ~ (unsigned int) 0; + unsigned int address = ~(unsigned int) 0; fragS *frag; fragS *frag_ptr; - unsigned int byte_in_frag; + unsigned int octet_in_frag; - /* Find first frag which says it belongs to this line */ + /* Find first frag which says it belongs to this line. */ frag = list->frag; while (frag && frag->line != list) frag = frag->fr_next; @@ -607,54 +778,48 @@ calc_hex (list) data_buffer_size = 0; - /* Dump all the frags which belong to this line */ + /* 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 */ - byte_in_frag = 0; - while ((offsetT) byte_in_frag < frag_ptr->fr_fix + /* Print as many bytes from the fixed part as is sensible. */ + octet_in_frag = 0; + while (octet_in_frag < frag_ptr->fr_fix && data_buffer_size < MAX_BYTES - 3) { - if (address == ~ (unsigned int) 0) - { - address = frag_ptr->fr_address; - } + if (address == ~(unsigned int) 0) + address = frag_ptr->fr_address / OCTETS_PER_BYTE; sprintf (data_buffer + data_buffer_size, "%02X", - (frag_ptr->fr_literal[byte_in_frag]) & 0xff); + (frag_ptr->fr_literal[octet_in_frag]) & 0xff); data_buffer_size += 2; - byte_in_frag++; + octet_in_frag++; } - { - unsigned int var_rep_max = byte_in_frag; - unsigned int var_rep_idx = byte_in_frag; + if (frag_ptr->fr_type == rs_fill) + { + unsigned int var_rep_max = octet_in_frag; + unsigned int var_rep_idx = octet_in_frag; - /* Print as many bytes from the variable part as is sensible */ - while (((offsetT) byte_in_frag - < frag_ptr->fr_fix + frag_ptr->fr_var * frag_ptr->fr_offset) - && data_buffer_size < MAX_BYTES - 3) - { - if (address == ~ (unsigned int) 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; + /* Print as many bytes from the variable part as is sensible. */ + while ((octet_in_frag + < frag_ptr->fr_fix + frag_ptr->fr_var * frag_ptr->fr_offset) + && data_buffer_size < MAX_BYTES - 3) + { + if (address == ~(unsigned int) 0) + address = frag_ptr->fr_address / OCTETS_PER_BYTE; - var_rep_idx++; - byte_in_frag++; + sprintf (data_buffer + data_buffer_size, + "%02X", + (frag_ptr->fr_literal[var_rep_idx]) & 0xff); + data_buffer_size += 2; - if ((offsetT) var_rep_idx >= frag_ptr->fr_fix + frag_ptr->fr_var) - var_rep_idx = var_rep_max; - } - } + var_rep_idx++; + octet_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; } @@ -662,41 +827,30 @@ calc_hex (list) return address; } - - - - - static void -print_lines (list, lineno, string, address) - list_info_type *list; - unsigned int lineno; - char *string; - unsigned int address; +print_lines (list_info_type *list, unsigned int lineno, + const char *string, unsigned int address) { unsigned int idx; unsigned int nchars; unsigned int lines; - unsigned int byte_in_word = 0; + unsigned int octet_in_word = 0; char *src = data_buffer; + int cur; + struct list_message *msg; - /* Print the stuff on the first line */ + /* Print the stuff on the first line. */ listing_page (list); nchars = (LISTING_WORD_SIZE * 2 + 1) * listing_lhs_width; - - /* Print the hex for the first line */ - if (address == ~ (unsigned int) 0) + + /* Print the hex for the first line. */ + if (address == ~(unsigned int) 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); - + emit_line (NULL, "\t%s\n", string ? string : ""); return; } @@ -705,93 +859,86 @@ print_lines (list, lineno, string, address) else fprintf (list_file, "% 4d %04x ", lineno, address); - /* And the data to go along with it */ + /* And the data to go along with it. */ idx = 0; - - while (*src && idx < nchars) + cur = 0; + while (src[cur] && idx < nchars) { - fprintf (list_file, "%c%c", src[0], src[1]); - src += 2; - byte_in_word++; - - if (byte_in_word == LISTING_WORD_SIZE) + int offset; + offset = cur; + fprintf (list_file, "%c%c", src[offset], src[offset + 1]); + cur += 2; + octet_in_word++; + + if (octet_in_word == LISTING_WORD_SIZE) { fprintf (list_file, " "); idx++; - byte_in_word = 0; + octet_in_word = 0; } - + idx += 2; } - + 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++; - } - + + emit_line (list, "\t%s\n", string ? string : ""); + + for (msg = list->messages; msg; msg = msg->next) + emit_line (list, "**** %s\n", msg->message); + for (lines = 0; lines < (unsigned int) listing_lhs_cont_lines - && *src; - lines ++) + && src[cur]; + lines++) { - nchars = ((LISTING_WORD_SIZE * 2) + 1) - * listing_lhs_width_second - 1; + nchars = ((LISTING_WORD_SIZE * 2) + 1) * listing_lhs_width_second - 1; idx = 0; - - /* Print any more lines of data, but more compactly */ + + /* Print any more lines of data, but more compactly. */ fprintf (list_file, "% 4d ", lineno); - - while (*src && idx < nchars) + + while (src[cur] && idx < nchars) { - fprintf (list_file, "%c%c", src[0], src[1]); - src += 2; + int offset; + offset = cur; + fprintf (list_file, "%c%c", src[offset], src[offset + 1]); + cur += 2; idx += 2; - byte_in_word++; - - if (byte_in_word == LISTING_WORD_SIZE) + octet_in_word++; + + if (octet_in_word == LISTING_WORD_SIZE) { fprintf (list_file, " "); idx++; - byte_in_word = 0; + octet_in_word = 0; } } - - fprintf (list_file, "\n"); - on_page ++; - listing_page (list); + + emit_line (list, "\n"); } } - static void -list_symbol_table () +list_symbol_table (void) { extern symbolS *symbol_rootP; int got_some = 0; symbolS *ptr; eject = 1; - listing_page (0); + listing_page (NULL); for (ptr = symbol_rootP; ptr != (symbolS *) NULL; ptr = symbol_next (ptr)) { if (SEG_NORMAL (S_GET_SEGMENT (ptr)) || S_GET_SEGMENT (ptr) == absolute_section) { -#ifdef BFD_ASSEMBLER /* Don't report section symbols. They are not interesting. */ - if (ptr->bsym->flags & BSF_SECTION_SYM) + if (symbol_section_p (ptr)) continue; -#endif + if (S_GET_NAME (ptr)) { char buf[30], fmt[8]; @@ -821,11 +968,11 @@ list_symbol_table () got_some = 1; } - if (ptr->sy_frag && ptr->sy_frag->line) + if (symbol_get_frag (ptr) && symbol_get_frag (ptr)->line) { fprintf (list_file, "%20s:%-5d %s:%s %s\n", - ptr->sy_frag->line->file->filename, - ptr->sy_frag->line->line, + symbol_get_frag (ptr)->line->file->filename, + symbol_get_frag (ptr)->line->line, segment_name (S_GET_SEGMENT (ptr)), buf, S_GET_NAME (ptr)); } @@ -836,8 +983,8 @@ list_symbol_table () buf, S_GET_NAME (ptr)); } - on_page ++; - listing_page (0); + on_page++; + listing_page (NULL); } } @@ -847,9 +994,7 @@ list_symbol_table () fprintf (list_file, "NO DEFINED SYMBOLS\n"); on_page++; } - fprintf (list_file, "\n"); - on_page++; - listing_page (0); + emit_line (NULL, "\n"); got_some = 0; @@ -862,41 +1007,111 @@ list_symbol_table () if (!got_some) { got_some = 1; - fprintf (list_file, "UNDEFINED SYMBOLS\n"); - on_page++; - listing_page (0); + + emit_line (NULL, "UNDEFINED SYMBOLS\n"); } - fprintf (list_file, "%s\n", S_GET_NAME (ptr)); - on_page++; - listing_page (0); + + emit_line (NULL, "%s\n", S_GET_NAME (ptr)); } } } + if (!got_some) - { - fprintf (list_file, "NO UNDEFINED SYMBOLS\n"); - on_page++; - listing_page (0); - } + emit_line (NULL, "NO UNDEFINED SYMBOLS\n"); } +typedef struct cached_line +{ + file_info_type * file; + unsigned int line; + char buffer [LISTING_RHS_WIDTH]; +} cached_line; + static void -print_source (current_file, list, buffer, width) - file_info_type *current_file; - list_info_type *list; - char *buffer; - unsigned int width; +print_source (file_info_type * current_file, + list_info_type * list, + unsigned int width) { +#define NUM_CACHE_LINES 3 + static cached_line cached_lines[NUM_CACHE_LINES]; + static int next_free_line = 0; + cached_line * cache = NULL; + + if (current_file->linenum > list->hll_line + && list->hll_line > 0) + { + /* This can happen with modern optimizing compilers. The source + lines from the high level language input program are split up + and interleaved, meaning the line number we want to display + (list->hll_line) can have already been displayed. We have + three choices: + + a. Do nothing, since we have already displayed the source + line. This was the old behaviour. + + b. Display the particular line requested again, but only + that line. This is the new behaviour. + + c. Display the particular line requested again and reset + the current_file->line_num value so that we redisplay + all the following lines as well the next time we + encounter a larger line number. */ + int i; + + /* Check the cache, maybe we already have the line saved. */ + for (i = 0; i < NUM_CACHE_LINES; i++) + if (cached_lines[i].file == current_file + && cached_lines[i].line == list->hll_line) + { + cache = cached_lines + i; + break; + } + + if (i == NUM_CACHE_LINES) + { + cache = cached_lines + next_free_line; + next_free_line ++; + if (next_free_line == NUM_CACHE_LINES) + next_free_line = 0; + + cache->file = current_file; + cache->line = list->hll_line; + cache->buffer[0] = 0; + rebuffer_line (current_file, cache->line, cache->buffer, width); + } + + emit_line (list, "%4u:%-13s **** %s\n", + cache->line, cache->file->filename, cache->buffer); + return; + } + if (!current_file->at_end) { + int num_lines_shown = 0; + while (current_file->linenum < list->hll_line && !current_file->at_end) { - char *p = buffer_line (current_file, buffer, width); - fprintf (list_file, "%4u:%-13s **** %s\n", current_file->linenum, - current_file->filename, p); - on_page++; - listing_page (list); + const char *p; + + cache = cached_lines + next_free_line; + cache->file = current_file; + cache->line = current_file->linenum + 1; + cache->buffer[0] = 0; + p = buffer_line (current_file, cache->buffer, width); + + /* Cache optimization: If printing a group of lines + cache the first and last lines in the group. */ + if (num_lines_shown == 0) + { + next_free_line ++; + if (next_free_line == NUM_CACHE_LINES) + next_free_line = 0; + } + + emit_line (list, "%4u:%-13s **** %s\n", + cache->line, cache->file->filename, p); + num_lines_shown ++; } } } @@ -905,23 +1120,26 @@ print_source (current_file, list, buffer, width) records inserted by the compiler, see if the line is suspicious. */ static int -debugging_pseudo (list, line) - list_info_type *list; - const char *line; +debugging_pseudo (list_info_type *list, const char *line) { +#ifdef OBJ_ELF static int in_debug; int was_debug; +#endif if (list->debugging) { +#ifdef OBJ_ELF in_debug = 1; +#endif return 1; } - +#ifdef OBJ_ELF was_debug = in_debug; in_debug = 0; +#endif - while (isspace ((unsigned char) *line)) + while (ISSPACE (*line)) line++; if (*line != '.') @@ -967,7 +1185,6 @@ debugging_pseudo (list, line) return 1; if (strncmp (line, "tag", 3) == 0) return 1; - if (strncmp (line, "stabs", 5) == 0) return 1; if (strncmp (line, "stabn", 5) == 0) @@ -977,36 +1194,23 @@ debugging_pseudo (list, line) } static void -listing_listing (name) - char *name; +listing_listing (char *name ATTRIBUTE_UNUSED) { list_info_type *list = head; file_info_type *current_hll_file = (file_info_type *) NULL; - char *message; char *buffer; - char *p; + const char *p; int show_listing = 1; unsigned int width; - buffer = xmalloc (listing_rhs_width); - data_buffer = xmalloc (MAX_BYTES); + buffer = XNEWVEC (char, listing_rhs_width); + data_buffer = XNEWVEC (char, MAX_BYTES); eject = 1; - list = head; - - while (list != (list_info_type *) NULL && 0) - { - if (list->next) - list->frag = list->next->frag; - list = list->next; - - } - list = head->next; - while (list) { - int list_line; + unsigned int list_line; width = listing_rhs_width > paper_width ? paper_width : listing_rhs_width; @@ -1022,6 +1226,8 @@ listing_listing (name) show_listing--; break; case EDICT_NOLIST_NEXT: + if (show_listing == 0) + list_line--; break; case EDICT_EJECT: break; @@ -1044,7 +1250,8 @@ listing_listing (name) p = buffer_line (list->file, buffer, width); } - if (list->edict == EDICT_LIST) + if (list->edict == EDICT_LIST + || (list->edict == EDICT_NOLIST_NEXT && show_listing == 0)) { /* Enable listing for the single line that caused the enable. */ list_line++; @@ -1055,27 +1262,20 @@ listing_listing (name) { /* 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; - } + current_hll_file = list->hll_file; if (current_hll_file && list->hll_line && (listing & LISTING_HLL)) - { - print_source (current_hll_file, list, buffer, width); - } + print_source (current_hll_file, list, width); if (list->line_contents) { if (!((listing & LISTING_NODEBUG) && debugging_pseudo (list, list->line_contents))) - { - print_lines (list, - list->file->linenum == 0 ? list->line : list->file->linenum, - list->line_contents, calc_hex (list)); - } + print_lines (list, + list->file->linenum == 0 ? list->line : list->file->linenum, + list->line_contents, calc_hex (list)); + free (list->line_contents); list->line_contents = NULL; } @@ -1089,7 +1289,7 @@ listing_listing (name) p = buffer_line (list->file, buffer, width); if (list->file->linenum < list_line) - address = ~ (unsigned int) 0; + address = ~(unsigned int) 0; else address = calc_hex (list); @@ -1100,12 +1300,10 @@ listing_listing (name) } if (list->edict == EDICT_EJECT) - { - eject = 1; - } + eject = 1; } - if (list->edict == EDICT_NOLIST_NEXT) + if (list->edict == EDICT_NOLIST_NEXT && show_listing == 1) --show_listing; list = list->next; @@ -1116,12 +1314,96 @@ listing_listing (name) data_buffer = NULL; } +/* Print time stamp in ISO format: yyyy-mm-ddThh:mm:ss.ss+/-zzzz. */ + +static void +print_timestamp (void) +{ + const time_t now = time (NULL); + struct tm * timestamp; + char stampstr[MAX_DATELEN]; + + /* Any portable way to obtain subsecond values??? */ + timestamp = localtime (&now); + strftime (stampstr, MAX_DATELEN, "%Y-%m-%dT%H:%M:%S.000%z", timestamp); + fprintf (list_file, _("\n time stamp \t: %s\n\n"), stampstr); +} + +static void +print_single_option (char * opt, int *pos) +{ + int opt_len = strlen (opt); + + if ((*pos + opt_len) < paper_width) + { + fprintf (list_file, _("%s "), opt); + *pos = *pos + opt_len; + } + else + { + fprintf (list_file, _("\n\t%s "), opt); + *pos = opt_len; + } +} + +/* Print options passed to as. */ + +static void +print_options (char ** argv) +{ + const char *field_name = _("\n options passed\t: "); + int pos = strlen (field_name); + char **p; + + fputs (field_name, list_file); + for (p = &argv[1]; *p != NULL; p++) + if (**p == '-') + { + /* Ignore these. */ + if (strcmp (*p, "-o") == 0) + { + if (p[1] != NULL) + p++; + continue; + } + if (strcmp (*p, "-v") == 0) + continue; + + print_single_option (*p, &pos); + } +} + +/* Print a first section with basic info like file names, as version, + options passed, target, and timestamp. + The format of this section is as follows: + + AS VERSION + + fieldname TAB ':' fieldcontents + { TAB fieldcontents-cont } */ + +static void +listing_general_info (char ** argv) +{ + /* Print the stuff on the first line. */ + eject = 1; + listing_page (NULL); + + fprintf (list_file, + _(" GNU assembler version %s (%s)\n\t using BFD version %s."), + VERSION, TARGET_ALIAS, BFD_VERSION_STRING); + print_options (argv); + fprintf (list_file, _("\n input file \t: %s"), fn); + fprintf (list_file, _("\n output file \t: %s"), out_file_name); + fprintf (list_file, _("\n target \t: %s"), TARGET_CANONICAL); + print_timestamp (); +} + void -listing_print (name) - char *name; +listing_print (char *name, char **argv) { int using_stdout; - + title = ""; subtitle = ""; @@ -1132,77 +1414,59 @@ listing_print (name) } else { - list_file = fopen (name, "w"); + list_file = fopen (name, FOPEN_WT); if (list_file != NULL) using_stdout = 0; else { - as_perror (_("can't open list file: %s"), name); + as_warn (_("can't open %s: %s"), name, xstrerror (errno)); list_file = stdout; using_stdout = 1; } } if (listing & LISTING_NOFORM) - { - paper_height = 0; - } + paper_height = 0; + + if (listing & LISTING_GENERAL) + listing_general_info (argv); if (listing & LISTING_LISTING) - { - listing_listing (name); - } + listing_listing (name); if (listing & LISTING_SYMBOLS) - { - list_symbol_table (); - } + list_symbol_table (); if (! using_stdout) { if (fclose (list_file) == EOF) - as_perror (_("error closing list file: %s"), name); + as_warn (_("can't close %s: %s"), name, xstrerror (errno)); } if (last_open_file) - { - fclose (last_open_file); - } + fclose (last_open_file); } - void -listing_file (name) - const char *name; +listing_file (const char *name) { fn = name; } void -listing_eject (ignore) - int ignore; +listing_eject (int ignore ATTRIBUTE_UNUSED) { if (listing) listing_tail->edict = EDICT_EJECT; } -void -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 -listing_list (on) - int on; +listing_list (int on) { if (listing) { @@ -1230,10 +1494,8 @@ listing_list (on) } } - void -listing_psize (width_only) - int width_only; +listing_psize (int width_only) { if (! width_only) { @@ -1260,15 +1522,13 @@ listing_psize (width_only) } void -listing_nopage (ignore) - int ignore; +listing_nopage (int ignore ATTRIBUTE_UNUSED) { paper_height = 0; } void -listing_title (depth) - int depth; +listing_title (int depth) { int quoted; char *start; @@ -1295,9 +1555,7 @@ listing_title (depth) if (listing) { length = input_line_pointer - start; - ttl = xmalloc (length + 1); - memcpy (ttl, start, length); - ttl[length] = 0; + ttl = xmemdup0 (start, length); listing_tail->edict = depth ? EDICT_SBTTL : EDICT_TITLE; listing_tail->edict_arg = ttl; } @@ -1308,7 +1566,7 @@ listing_title (depth) } else if (*input_line_pointer == '\n') { - as_bad (_("New line in title")); + as_bad (_("new line in title")); demand_empty_rest_of_line (); return; } @@ -1319,11 +1577,8 @@ listing_title (depth) } } - - void -listing_source_line (line) - unsigned int line; +listing_source_line (unsigned int line) { if (listing) { @@ -1334,87 +1589,64 @@ listing_source_line (line) } void -listing_source_file (file) - const char *file; +listing_source_file (const char *file) { if (listing) listing_tail->hll_file = file_info (file); } - - #else - -/* Dummy functions for when compiled without listing enabled */ +/* Dummy functions for when compiled without listing enabled. */ void -listing_flags (ignore) - int ignore; +listing_list (int on) { s_ignore (0); } -void -listing_list (on) - int on; +void +listing_eject (int ignore) { s_ignore (0); } -void -listing_eject (ignore) - int ignore; +void +listing_psize (int ignore) { s_ignore (0); } -void -listing_psize (ignore) - int ignore; +void +listing_nopage (int ignore) { s_ignore (0); } void -listing_nopage (ignore) - int ignore; +listing_title (int depth) { s_ignore (0); } -void -listing_title (depth) - int depth; +void +listing_file (const char *name) { - s_ignore (0); } void -listing_file (name) - const char *name; +listing_newline (char *name) { - } -void -listing_newline (name) - char *name; +void +listing_source_line (unsigned int n) { - } -void -listing_source_line (n) - unsigned int n; -{ - -} -void -listing_source_file (n) - const char *n; +void +listing_source_file (const char *n) { - } #endif