/* listing.c - maintain assembly listings
- Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
- 2001, 2002, 2003, 2005
- Free Software Foundation, Inc.
+ Copyright (C) 1991-2020 Free Software Foundation, Inc.
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)
+ 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,
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
#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
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;
-
- len = (copy - input_line_pointer) + 2;
+ {
+ if (seen_slash)
+ seen_slash = 0;
+ else if (*copy == '\\')
+ seen_slash = 1;
+ else if (*copy == '"')
+ seen_quote = !seen_quote;
+ }
- copy = xmalloc (len);
+ len = copy - input_line_pointer + 1;
- if (copy != NULL)
- {
- char *src = input_line_pointer - 1;
- char *dest = copy;
+ copy = XNEWVEC (char, len);
- while (--len)
- {
- unsigned char c = *src++;
+ src = input_line_pointer;
+ dest = copy;
- /* 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. */
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;
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;
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;
+
+ 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;
+ }
- fprintf (list_file, "%4u:%-13s **** %s\n", current_file->linenum,
- current_file->filename, p);
- on_page++;
- listing_page (list);
+ 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;
-
- while (list != (list_info_type *) NULL && 0)
- {
- if (list->next)
- list->frag = list->next->frag;
- list = list->next;
- }
-
list = head->next;
while (list)
{
/* 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)
{
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;
using_stdout = 0;
else
{
- bfd_set_error (bfd_error_system_call);
- 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;
+ if (listing & LISTING_GENERAL)
+ listing_general_info (argv);
+
if (listing & LISTING_LISTING)
listing_listing (name);
if (! using_stdout)
{
if (fclose (list_file) == EOF)
- {
- bfd_set_error (bfd_error_system_call);
- as_perror (_("error closing list file: %s"), name);
- }
+ as_warn (_("can't close %s: %s"), name, xstrerror (errno));
}
if (last_open_file)
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)
{