/* listing.c - maintain assembly listings
- Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
- 2001, 2002, 2003, 2005, 2006, 2007, 2008
- Free Software Foundation, Inc.
+ Copyright (C) 1991-2020 Free Software Foundation, Inc.
This file is part of GAS, the GNU Assembler.
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
on a line. */
#include "as.h"
-#include "obstack.h"
+#include "filenames.h"
#include "safe-ctype.h"
#include "input-file.h"
#include "subsegs.h"
#include "bfdver.h"
#include <time.h>
+#include <stdarg.h>
#ifndef NO_LISTING
int at_end;
} 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 remembers which line from which file goes into which
frag. */
struct list_info_struct
/* 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;
+ enum edict_enum edict;
char *edict_arg;
/* Nonzero if this line is to be omitted because it contains
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 print_lines (list_info_type *, unsigned int, const 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 *);
{
if (listing_tail != (list_info_type *) NULL)
{
- unsigned int l = strlen (name) + strlen (message) + 1;
- char *n = (char *) xmalloc (l);
- strcpy (n, name);
- strcat (n, message);
- 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 (const char *message)
{
- listing_message (_("Warning:"), message);
+ listing_message (_("Warning: "), message);
}
void
listing_error (const char *message)
{
- listing_message (_("Error:"), message);
+ listing_message (_("Error: "), message);
}
static file_info_type *
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 = xmalloc (sizeof (file_info_type));
+ p = XNEW (file_info_type);
p->next = file_info_head;
file_info_head = p;
p->filename = xstrdup (file_name);
void
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;
}
#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)))
+ && !(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().
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;
+ for (copy = input_line_pointer;
*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 (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)
- {
- char *src = input_line_pointer - 1;
- char *dest = copy;
+ src = input_line_pointer;
+ dest = copy;
- while (--len)
- {
- unsigned char c = *src++;
-
- /* Omit control characters in the listing. */
- if (!ISCNTRL (c))
- *dest++ = c;
- }
+ while (--len)
+ {
+ unsigned char c = *src++;
- *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 = xmalloc (sizeof (list_info_type));
- new->line_contents = ps;
+ new_i = XNEW (list_info_type);
+ new_i->line_contents = ps;
}
last_line = line;
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->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 ();
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
}
/* 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 *
+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. */
fseek (last_open_file, file->pos, SEEK_SET);
}
- c = fgetc (last_open_file);
-
/* Leave room for null. */
size -= 1;
+ c = fgetc (last_open_file);
+
while (c != EOF && c != '\n' && c != '\r')
{
if (count < size)
count++;
c = fgetc (last_open_file);
-
}
/* If '\r' is followed by '\n', swallow that. Likewise, if '\n'
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);
return line;
}
-static const char *fn;
-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 */
+/* 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++;
+
+ 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_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)
{
{
/* Print as many bytes from the fixed part as is sensible. */
octet_in_frag = 0;
- while ((offsetT) octet_in_frag < frag_ptr->fr_fix
+ while (octet_in_frag < frag_ptr->fr_fix
&& data_buffer_size < MAX_BYTES - 3)
{
if (address == ~(unsigned int) 0)
unsigned int var_rep_idx = octet_in_frag;
/* Print as many bytes from the variable part as is sensible. */
- while (((offsetT) octet_in_frag
- < (frag_ptr->fr_fix + frag_ptr->fr_var * frag_ptr->fr_offset))
+ 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)
var_rep_idx++;
octet_in_frag++;
- if ((offsetT) var_rep_idx >= frag_ptr->fr_fix + frag_ptr->fr_var)
+ if (var_rep_idx >= frag_ptr->fr_fix + frag_ptr->fr_var)
var_rep_idx = var_rep_max;
}
}
static void
print_lines (list_info_type *list, unsigned int lineno,
- char *string, unsigned int address)
+ const char *string, unsigned int address)
{
unsigned int idx;
unsigned int nchars;
unsigned int octet_in_word = 0;
char *src = data_buffer;
int cur;
+ struct list_message *msg;
/* Print the stuff on the first line. */
listing_page (list);
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;
}
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++;
- }
+ 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
}
}
- fprintf (list_file, "\n");
- on_page++;
- listing_page (list);
+ emit_line (list, "\n");
}
}
symbolS *ptr;
eject = 1;
- listing_page (0);
+ listing_page (NULL);
for (ptr = symbol_rootP; ptr != (symbolS *) NULL; ptr = symbol_next (ptr))
{
}
on_page++;
- listing_page (0);
+ listing_page (NULL);
}
}
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;
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);
+ const char *p;
- fprintf (list_file, "%4u:%-13s **** %s\n", current_file->linenum,
- current_file->filename, p);
- on_page++;
- listing_page (list);
+ 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 ++;
}
}
}
static int
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 (*line))
line++;
{
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->next;
{
/* 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);
+ print_source (current_hll_file, list, width);
if (list->line_contents)
{
{
/* Print the stuff on the first line. */
eject = 1;
- listing_page (0);
+ listing_page (NULL);
fprintf (list_file,
_(" GNU assembler version %s (%s)\n\t using BFD version %s."),
listing_tail->edict = EDICT_EJECT;
}
-void
-listing_flags (int ignore ATTRIBUTE_UNUSED)
-{
- 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,
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;
}
/* Dummy functions for when compiled without listing enabled. */
-void
-listing_flags (int ignore)
-{
- s_ignore (0);
-}
-
void
listing_list (int on)
{
projects / deliverable / binutils-gdb.git / blobdiff