X-Git-Url: https://oss.titaniummirror.com/gitweb?p=msp430-binutils.git;a=blobdiff_plain;f=gas%2Flisting.c;fp=gas%2Flisting.c;h=c8b6d63bc4f1823b4fb4c7751ece80f94ec7488f;hp=1eca6475830907331cb180fa0edeb59875dc9ba5;hb=d5da4f291af551c0b8b79e1d4a9b173d60e5c10e;hpb=7b5ea4fcdf2819e070665ab5610f8b48e3867c10 diff --git a/gas/listing.c b/gas/listing.c index 1eca647..c8b6d63 100644 --- a/gas/listing.c +++ b/gas/listing.c @@ -1,6 +1,6 @@ /* listing.c - maintain assembly listings Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, - 2001, 2002, 2003, 2005, 2006, 2007 + 2001, 2002, 2003, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc. This file is part of GAS, the GNU Assembler. @@ -94,6 +94,9 @@ #include "safe-ctype.h" #include "input-file.h" #include "subsegs.h" +#include "bfdver.h" +#include +#include #ifndef NO_LISTING @@ -115,6 +118,7 @@ #ifndef LISTING_LHS_CONT_LINES #define LISTING_LHS_CONT_LINES 4 #endif +#define MAX_DATELEN 30 /* This structure remembers which .s were used. */ typedef struct file_info_struct @@ -126,6 +130,18 @@ typedef struct file_info_struct int at_end; } file_info_type; +enum edict_enum +{ + EDICT_NONE, + EDICT_SBTTL, + EDICT_TITLE, + EDICT_NOLIST, + EDICT_LIST, + EDICT_NOLIST_NEXT, + EDICT_EJECT +}; + + /* This structure remembers which line from which file goes into which frag. */ struct list_info_struct @@ -156,16 +172,7 @@ struct list_info_struct /* Pointer to any error message associated with this line. */ char *message; - enum - { - EDICT_NONE, - EDICT_SBTTL, - EDICT_TITLE, - EDICT_NOLIST, - EDICT_LIST, - EDICT_NOLIST_NEXT, - EDICT_EJECT - } edict; + enum edict_enum edict; char *edict_arg; /* Nonzero if this line is to be omitted because it contains @@ -210,12 +217,10 @@ static char *data_buffer; static void listing_message (const char *, const char *); static file_info_type *file_info (const char *); static void new_frag (void); -static char *buffer_line (file_info_type *, char *, unsigned int); static void listing_page (list_info_type *); static unsigned int calc_hex (list_info_type *); static void print_lines (list_info_type *, unsigned int, char *, unsigned int); static void list_symbol_table (void); -static void print_source (file_info_type *, list_info_type *, char *, unsigned int); static int debugging_pseudo (list_info_type *, const char *); static void listing_listing (char *); @@ -258,7 +263,7 @@ file_info (const char *file_name) } /* Make new entry. */ - p = 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 = xstrdup (file_name); @@ -283,7 +288,7 @@ listing_newline (char *ps) unsigned int line; static unsigned int last_line = 0xffff; static char *last_file = NULL; - list_info_type *new = NULL; + list_info_type *new_i = NULL; if (listing == 0) return; @@ -316,7 +321,7 @@ listing_newline (char *ps) && !(last_file && file && strcmp (file, last_file))) return; - new = (list_info_type *) xmalloc (sizeof (list_info_type)); + new_i = (list_info_type *) xmalloc (sizeof (list_info_type)); /* Detect if we are reading from stdin by examining the file name returned by as_where(). @@ -335,17 +340,22 @@ listing_newline (char *ps) char *copy; 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])); + || is_end_of_line [(unsigned char) *copy] != 1); copy++) - if (*copy == '"' && copy[-1] != '\\') - seen_quote = ! seen_quote; + { + if (*copy == '\\') + seen_slash = ! seen_slash; + else if (*copy == '"' && seen_slash) + seen_quote = ! seen_quote; + } len = (copy - input_line_pointer) + 2; - copy = xmalloc (len); + copy = (char *) xmalloc (len); if (copy != NULL) { @@ -364,15 +374,15 @@ listing_newline (char *ps) *dest = 0; } - new->line_contents = copy; + new_i->line_contents = copy; } else - new->line_contents = NULL; + new_i->line_contents = NULL; } else { - new = xmalloc (sizeof (list_info_type)); - new->line_contents = ps; + new_i = (list_info_type *) xmalloc (sizeof (list_info_type)); + new_i->line_contents = ps; } last_line = line; @@ -381,21 +391,21 @@ listing_newline (char *ps) new_frag (); if (listing_tail) - listing_tail->next = new; + listing_tail->next = new_i; else - head = new; + head = new_i; - listing_tail = new; + listing_tail = new_i; - 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_i->frag = frag_now; + new_i->line = line; + new_i->file = file_info (file); + new_i->next = (list_info_type *) NULL; + new_i->message = (char *) 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 (); @@ -409,7 +419,7 @@ listing_newline (char *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 } @@ -445,14 +455,13 @@ listing_prev_line (void) /* 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. */ + file to make using the returned buffer simpler. */ static 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. */ @@ -468,8 +477,10 @@ buffer_line (file_info_type *file, char *line, unsigned int 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, FOPEN_RT); + last_open_file = fopen (file->filename, FOPEN_RB); if (last_open_file == NULL) { file->at_end = 1; @@ -481,20 +492,31 @@ buffer_line (file_info_type *file, char *line, unsigned int size) fseek (last_open_file, file->pos, SEEK_SET); } - c = fgetc (last_open_file); - /* Leave room for null. */ size -= 1; - while (c != EOF && c != '\n') + c = fgetc (last_open_file); + + 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; @@ -510,6 +532,117 @@ buffer_line (file_info_type *file, char *line, unsigned int size) return line; } + +/* 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 char * +rebuffer_line (file_info_type * file, + unsigned int linenum, + char * buffer, + unsigned int size) +{ + unsigned int count = 0; + unsigned int current_line = 1; + char * p = buffer; + long pos; + int c; + + /* Sanity checks. */ + if (file == NULL || buffer == NULL || size == 0 || 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. */ + pos = ftell (last_open_file); + + /* Go back to the beginning. */ + fseek (last_open_file, 0, SEEK_SET); + + /* Skip lines prior to the one we are interested in. */ + while (current_line < linenum) + { + /* fgets only stops on newlines and has a size limit, + so we read one character at a time instead. */ + do + { + c = fgetc (last_open_file); + } + while (c != EOF && c != '\n' && c != '\r'); + + ++ current_line; + + if (c == '\r' || c == '\n') + { + int next = 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' && next != '\n') + || (c == '\n' && next != '\r')) + ungetc (next, last_open_file); + } + } + + /* Leave room for the nul at the end of the buffer. */ + size -= 1; + + /* Read in the line. */ + c = fgetc (last_open_file); + + 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); + } + + /* Terminate the line. */ + *p++ = 0; + + /* Reset the file position. */ + fseek (last_open_file, pos, SEEK_SET); + + return buffer; +} + static const char *fn; static unsigned int eject; /* Eject pending */ @@ -561,6 +694,23 @@ listing_page (list_info_type *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_info_type *list) { @@ -651,12 +801,7 @@ print_lines (list_info_type *list, unsigned int 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; } @@ -689,16 +834,10 @@ print_lines (list_info_type *list, unsigned int lineno, for (; idx < nchars; idx++) fprintf (list_file, " "); - fprintf (list_file, "\t%s\n", string ? string : ""); - on_page++; - listing_page (list); + emit_line (list, "\t%s\n", string ? string : ""); if (list->message) - { - fprintf (list_file, "**** %s\n", list->message); - listing_page (list); - on_page++; - } + emit_line (list, "**** %s\n", list->message); for (lines = 0; lines < (unsigned int) listing_lhs_cont_lines @@ -728,9 +867,7 @@ print_lines (list_info_type *list, unsigned int lineno, } } - fprintf (list_file, "\n"); - on_page++; - listing_page (list); + emit_line (list, "\n"); } } @@ -742,7 +879,7 @@ list_symbol_table (void) symbolS *ptr; eject = 1; - listing_page (0); + listing_page (NULL); for (ptr = symbol_rootP; ptr != (symbolS *) NULL; ptr = symbol_next (ptr)) { @@ -798,7 +935,7 @@ list_symbol_table (void) } on_page++; - listing_page (0); + listing_page (NULL); } } @@ -808,9 +945,7 @@ list_symbol_table (void) 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; @@ -823,39 +958,111 @@ list_symbol_table (void) 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 (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); + cached_line * cache = cached_lines + next_free_line; + char *p; + + cache->file = current_file; + cache->line = current_file->linenum; + cache->buffer[0] = 0; + p = buffer_line (current_file, cache->buffer, width); - fprintf (list_file, "%4u:%-13s **** %s\n", current_file->linenum, - current_file->filename, p); - on_page++; - listing_page (list); + /* 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 ++; } } } @@ -943,8 +1150,8 @@ listing_listing (char *name ATTRIBUTE_UNUSED) int show_listing = 1; unsigned int width; - buffer = xmalloc (listing_rhs_width); - data_buffer = xmalloc (MAX_BYTES); + buffer = (char *) xmalloc (listing_rhs_width); + data_buffer = (char *) xmalloc (MAX_BYTES); eject = 1; list = head->next; @@ -1008,7 +1215,7 @@ listing_listing (char *name ATTRIBUTE_UNUSED) 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) { @@ -1056,8 +1263,93 @@ listing_listing (char *name ATTRIBUTE_UNUSED) 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 (char *name) +listing_print (char *name, char **argv) { int using_stdout; @@ -1085,6 +1377,9 @@ listing_print (char *name) if (listing & LISTING_NOFORM) paper_height = 0; + if (listing & LISTING_GENERAL) + listing_general_info (argv); + if (listing & LISTING_LISTING) listing_listing (name); @@ -1217,7 +1512,7 @@ listing_title (int depth) if (listing) { length = input_line_pointer - start; - ttl = xmalloc (length + 1); + ttl = (char *) xmalloc (length + 1); memcpy (ttl, start, length); ttl[length] = 0; listing_tail->edict = depth ? EDICT_SBTTL : EDICT_TITLE;