/* objcopy.c -- copy object file from input to output, optionally massaging it.
- Copyright (C) 1991, 92, 93, 94 Free Software Foundation, Inc.
+ Copyright (C) 1991, 92, 93, 94, 95, 1996 Free Software Foundation, Inc.
This file is part of GNU Binutils.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
- Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
\f
#include "bfd.h"
-#include "sysdep.h"
+#include "progress.h"
#include "bucomm.h"
-#include <getopt.h>
-
-static void setup_section ();
-static void copy_section ();
-static void mark_symbols_used_in_relocations ();
+#include "getopt.h"
+#include "libiberty.h"
+#include "budbg.h"
+#include <sys/stat.h>
+
+static flagword parse_flags PARAMS ((const char *));
+static struct section_list *find_section_list PARAMS ((const char *, boolean));
+static void setup_section PARAMS ((bfd *, asection *, PTR));
+static void copy_section PARAMS ((bfd *, asection *, PTR));
+static void get_sections PARAMS ((bfd *, asection *, PTR));
+static int compare_section_vma PARAMS ((const PTR, const PTR));
+static void add_strip_symbol PARAMS ((const char *));
+static boolean is_strip_symbol PARAMS ((const char *));
+static boolean is_strip_section PARAMS ((bfd *, asection *));
+static unsigned int filter_symbols
+ PARAMS ((bfd *, asymbol **, asymbol **, long));
+static void mark_symbols_used_in_relocations PARAMS ((bfd *, asection *, PTR));
+static boolean write_debugging_info PARAMS ((bfd *, PTR, long *, asymbol ***));
#define nonfatal(s) {bfd_nonfatal(s); status = 1; return;}
strip_undef,
strip_none, /* don't strip */
strip_debug, /* strip all debugger symbols */
+ strip_unneeded, /* strip unnecessary symbols */
strip_all /* strip all symbols */
};
/* Which local symbols to remove. Overrides strip_all. */
static enum locals_action discard_locals;
+/* Structure used to hold lists of sections and actions to take. */
+
+struct section_list
+{
+ /* Next section to adjust. */
+ struct section_list *next;
+ /* Section name. */
+ const char *name;
+ /* Whether this entry was used. */
+ boolean used;
+ /* Whether to remove this section. */
+ boolean remove;
+ /* Whether to adjust or set VMA. */
+ enum { ignore_vma, adjust_vma, set_vma } adjust;
+ /* Amount to adjust by or set to. */
+ bfd_vma val;
+ /* Whether to set the section flags. */
+ boolean set_flags;
+ /* What to set the section flags to. */
+ flagword flags;
+};
+
+static struct section_list *adjust_sections;
+static boolean sections_removed;
+
+/* Adjustments to the start address. */
+static bfd_vma adjust_start = 0;
+static boolean set_start_set = false;
+static bfd_vma set_start;
+
+/* Adjustments to section VMA's. */
+static bfd_vma adjust_section_vma = 0;
+
+/* Filling gaps between sections. */
+static boolean gap_fill_set = false;
+static bfd_byte gap_fill = 0;
+
+/* Pad to a given address. */
+static boolean pad_to_set = false;
+static bfd_vma pad_to;
+
+/* List of sections to add. */
+
+struct section_add
+{
+ /* Next section to add. */
+ struct section_add *next;
+ /* Name of section to add. */
+ const char *name;
+ /* Name of file holding section contents. */
+ const char *filename;
+ /* Size of file. */
+ size_t size;
+ /* Contents of file. */
+ bfd_byte *contents;
+ /* BFD section, after it has been added. */
+ asection *section;
+};
+
+static struct section_add *add_sections;
+
+/* Whether to convert debugging information. */
+
+static boolean convert_debugging = false;
+
+/* 150 isn't special; it's just an arbitrary non-ASCII char value. */
+
+#define OPTION_ADD_SECTION 150
+#define OPTION_ADJUST_START (OPTION_ADD_SECTION + 1)
+#define OPTION_ADJUST_VMA (OPTION_ADJUST_START + 1)
+#define OPTION_ADJUST_SECTION_VMA (OPTION_ADJUST_VMA + 1)
+#define OPTION_ADJUST_WARNINGS (OPTION_ADJUST_SECTION_VMA + 1)
+#define OPTION_DEBUGGING (OPTION_ADJUST_WARNINGS + 1)
+#define OPTION_GAP_FILL (OPTION_DEBUGGING + 1)
+#define OPTION_NO_ADJUST_WARNINGS (OPTION_GAP_FILL + 1)
+#define OPTION_PAD_TO (OPTION_NO_ADJUST_WARNINGS + 1)
+#define OPTION_SET_SECTION_FLAGS (OPTION_PAD_TO + 1)
+#define OPTION_SET_START (OPTION_SET_SECTION_FLAGS + 1)
+#define OPTION_STRIP_UNNEEDED (OPTION_SET_START + 1)
+
/* Options to handle if running as "strip". */
static struct option strip_options[] =
{"help", no_argument, 0, 'h'},
{"input-format", required_argument, 0, 'I'}, /* Obsolete */
{"input-target", required_argument, 0, 'I'},
+ {"keep-symbol", required_argument, 0, 'K'},
{"output-format", required_argument, 0, 'O'}, /* Obsolete */
{"output-target", required_argument, 0, 'O'},
+ {"remove-section", required_argument, 0, 'R'},
{"strip-all", no_argument, 0, 's'},
{"strip-debug", no_argument, 0, 'S'},
+ {"strip-unneeded", no_argument, 0, OPTION_STRIP_UNNEEDED},
+ {"strip-symbol", required_argument, 0, 'N'},
{"target", required_argument, 0, 'F'},
{"verbose", no_argument, 0, 'v'},
{"version", no_argument, 0, 'V'},
static struct option copy_options[] =
{
+ {"add-section", required_argument, 0, OPTION_ADD_SECTION},
+ {"adjust-start", required_argument, 0, OPTION_ADJUST_START},
+ {"adjust-vma", required_argument, 0, OPTION_ADJUST_VMA},
+ {"adjust-section-vma", required_argument, 0, OPTION_ADJUST_SECTION_VMA},
+ {"adjust-warnings", no_argument, 0, OPTION_ADJUST_WARNINGS},
{"byte", required_argument, 0, 'b'},
+ {"debugging", no_argument, 0, OPTION_DEBUGGING},
{"discard-all", no_argument, 0, 'x'},
{"discard-locals", no_argument, 0, 'X'},
{"format", required_argument, 0, 'F'}, /* Obsolete */
+ {"gap-fill", required_argument, 0, OPTION_GAP_FILL},
{"help", no_argument, 0, 'h'},
{"input-format", required_argument, 0, 'I'}, /* Obsolete */
{"input-target", required_argument, 0, 'I'},
{"interleave", required_argument, 0, 'i'},
+ {"keep-symbol", required_argument, 0, 'K'},
+ {"no-adjust-warnings", no_argument, 0, OPTION_NO_ADJUST_WARNINGS},
{"output-format", required_argument, 0, 'O'}, /* Obsolete */
{"output-target", required_argument, 0, 'O'},
+ {"pad-to", required_argument, 0, OPTION_PAD_TO},
+ {"remove-section", required_argument, 0, 'R'},
+ {"set-section-flags", required_argument, 0, OPTION_SET_SECTION_FLAGS},
+ {"set-start", required_argument, 0, OPTION_SET_START},
{"strip-all", no_argument, 0, 'S'},
{"strip-debug", no_argument, 0, 'g'},
+ {"strip-unneeded", no_argument, 0, OPTION_STRIP_UNNEEDED},
+ {"strip-symbol", required_argument, 0, 'N'},
{"target", required_argument, 0, 'F'},
{"verbose", no_argument, 0, 'v'},
{"version", no_argument, 0, 'V'},
static void
-copy_usage (stream, status)
+copy_usage (stream, exit_status)
FILE *stream;
- int status;
+ int exit_status;
{
fprintf (stream, "\
Usage: %s [-vVSgxX] [-I bfdname] [-O bfdname] [-F bfdname] [-b byte]\n\
- [-i interleave] [--interleave=interleave] [--byte=byte]\n\
+ [-R section] [-i interleave] [--interleave=interleave] [--byte=byte]\n\
[--input-target=bfdname] [--output-target=bfdname] [--target=bfdname]\n\
- [--strip-all] [--strip-debug] [--discard-all] [--discard-locals]\n\
- [--verbose] [--version] [--help] in-file [out-file]\n",
+ [--strip-all] [--strip-debug] [--strip-unneeded] [--discard-all]\n\
+ [--discard-locals] [--debugging] [--remove-section=section]\n",
program_name);
- exit (status);
+ fprintf (stream, "\
+ [--gap-fill=val] [--pad-to=address]\n\
+ [--set-start=val] [--adjust-start=incr]\n\
+ [--adjust-vma=incr] [--adjust-section-vma=section{=,+,-}val]\n\
+ [--adjust-warnings] [--no-adjust-warnings]\n\
+ [--set-section-flags=section=flags] [--add-section=sectionname=filename]\n\
+ [--keep-symbol symbol] [-K symbol] [--strip-symbol symbol] [-N symbol]\n\
+ [--verbose] [--version] [--help]\n\
+ in-file [out-file]\n");
+ list_supported_targets (program_name, stream);
+ exit (exit_status);
}
static void
-strip_usage (stream, status)
+strip_usage (stream, exit_status)
FILE *stream;
- int status;
+ int exit_status;
{
fprintf (stream, "\
-Usage: %s [-vVsSgxX] [-I bfdname] [-O bfdname] [-F bfdname]\n\
+Usage: %s [-vVsSgxX] [-I bfdname] [-O bfdname] [-F bfdname] [-R section]\n\
[--input-target=bfdname] [--output-target=bfdname] [--target=bfdname]\n\
- [--strip-all] [--strip-debug] [--discard-all] [--discard-locals]\n\
+ [--strip-all] [--strip-debug] [--strip-unneeded] [--discard-all]\n\
+ [--discard-locals] [--keep-symbol symbol] [-K symbol]\n\
+ [--strip-symbol symbol] [-N symbol] [--remove-section=section]\n\
[--verbose] [--version] [--help] file...\n",
program_name);
- exit (status);
+ list_supported_targets (program_name, stream);
+ exit (exit_status);
}
+/* Parse section flags into a flagword, with a fatal error if the
+ string can't be parsed. */
-/* Return the name of a temporary file in the same directory as FILENAME. */
-
-static char *
-make_tempname (filename)
- char *filename;
+static flagword
+parse_flags (s)
+ const char *s;
{
- static char template[] = "stXXXXXX";
- char *tmpname;
- char *slash = strrchr (filename, '/');
+ flagword ret;
+ const char *snext;
+ int len;
- if (slash != (char *) NULL)
+ ret = SEC_NO_FLAGS;
+
+ do
{
- *slash = 0;
- tmpname = xmalloc (strlen (filename) + sizeof (template) + 1);
- strcpy (tmpname, filename);
- strcat (tmpname, "/");
- strcat (tmpname, template);
- mktemp (tmpname);
- *slash = '/';
+ snext = strchr (s, ',');
+ if (snext == NULL)
+ len = strlen (s);
+ else
+ {
+ len = snext - s;
+ ++snext;
+ }
+
+#define PARSE_FLAG(fname,fval) if (strncmp (fname, s, len) == 0) ret |= fval;
+ PARSE_FLAG ("alloc", SEC_ALLOC);
+ PARSE_FLAG ("load", SEC_LOAD);
+ PARSE_FLAG ("readonly", SEC_READONLY);
+ PARSE_FLAG ("code", SEC_CODE);
+ PARSE_FLAG ("data", SEC_DATA);
+ PARSE_FLAG ("rom", SEC_ROM);
+#undef PARSE_FLAG
+
+ s = snext;
}
- else
+ while (s != NULL);
+
+ return ret;
+}
+
+/* Find and optionally add an entry in the adjust_sections list. */
+
+static struct section_list *
+find_section_list (name, add)
+ const char *name;
+ boolean add;
+{
+ register struct section_list *p;
+
+ for (p = adjust_sections; p != NULL; p = p->next)
+ if (strcmp (p->name, name) == 0)
+ return p;
+
+ if (! add)
+ return NULL;
+
+ p = (struct section_list *) xmalloc (sizeof (struct section_list));
+ p->name = name;
+ p->used = false;
+ p->remove = false;
+ p->adjust = ignore_vma;
+ p->val = 0;
+ p->set_flags = false;
+ p->flags = 0;
+
+ p->next = adjust_sections;
+ adjust_sections = p;
+
+ return p;
+}
+
+/* Make a list of symbols to explicitly strip out, or to keep. A
+ linked list is good enough for a small number from the command
+ line, but this will slow things down a lot if many symbols are
+ being deleted. */
+
+struct symlist
+{
+ const char *name;
+ struct symlist *next;
+};
+
+/* List of symbols to strip. */
+
+static struct symlist *strip_specific_list = NULL;
+
+/* If this is false, we strip the symbols in strip_specific_list.
+ Otherwise, we keep only the symbols in the list. */
+
+static boolean keep_symbols = false;
+
+/* Add a symbol to strip_specific_list. */
+
+static void
+add_strip_symbol (name)
+ const char *name;
+{
+ struct symlist *tmp_list;
+
+ tmp_list = (struct symlist *) xmalloc (sizeof (struct symlist));
+ tmp_list->name = name;
+ tmp_list->next = strip_specific_list;
+ strip_specific_list = tmp_list;
+}
+
+/* See whether a symbol should be stripped or kept based on
+ strip_specific_list and keep_symbols. */
+
+static boolean
+is_strip_symbol (name)
+ const char *name;
+{
+ struct symlist *tmp_list;
+
+ for (tmp_list = strip_specific_list; tmp_list; tmp_list = tmp_list->next)
{
- tmpname = xmalloc (sizeof (template));
- strcpy (tmpname, template);
- mktemp (tmpname);
+ if (strcmp (name, tmp_list->name) == 0)
+ return keep_symbols ? false : true;
}
- return tmpname;
+ return keep_symbols;
+}
+
+/* See if a section is being removed. */
+
+static boolean
+is_strip_section (abfd, sec)
+ bfd *abfd;
+ asection *sec;
+{
+ struct section_list *p;
+
+ if ((bfd_get_section_flags (abfd, sec) & SEC_DEBUGGING) != 0
+ && (strip_symbols == strip_debug
+ || strip_symbols == strip_unneeded
+ || strip_symbols == strip_all
+ || discard_locals == locals_all
+ || convert_debugging))
+ return true;
+
+ if (! sections_removed)
+ return false;
+ p = find_section_list (bfd_get_section_name (abfd, sec), false);
+ return p != NULL && p->remove ? true : false;
}
/* Choose which symbol entries to copy; put the result in OSYMS.
flagword flags = sym->flags;
int keep;
- if ((flags & BSF_GLOBAL) /* Keep if external. */
- || (flags & BSF_KEEP) /* Keep if used in a relocation. */
- || bfd_get_section (sym) == &bfd_und_section
- || bfd_is_com_section (bfd_get_section (sym)))
+ if ((flags & BSF_KEEP) != 0) /* Used in relocation. */
keep = 1;
+ else if ((flags & BSF_GLOBAL) != 0 /* Global symbol. */
+ || bfd_is_und_section (bfd_get_section (sym))
+ || bfd_is_com_section (bfd_get_section (sym)))
+ keep = strip_symbols != strip_unneeded;
else if ((flags & BSF_DEBUGGING) != 0) /* Debugging symbol. */
- keep = strip_symbols != strip_debug;
+ keep = (strip_symbols != strip_debug
+ && strip_symbols != strip_unneeded
+ && ! convert_debugging);
else /* Local symbol. */
- keep = discard_locals != locals_all
- && (discard_locals != locals_start_L ||
- ! bfd_is_local_label (abfd, sym));
+ keep = (strip_symbols != strip_unneeded
+ && (discard_locals != locals_all
+ && (discard_locals != locals_start_L
+ || ! bfd_is_local_label (abfd, sym))));
+
+ if (keep && is_strip_symbol (bfd_asymbol_name (sym)))
+ keep = 0;
+ if (keep && is_strip_section (abfd, bfd_get_section (sym)))
+ keep = 0;
+
if (keep)
to[dst_count++] = sym;
}
bfd *ibfd;
bfd *obfd;
{
+ bfd_vma start;
long symcount;
+ asection **osections = NULL;
+ bfd_size_type *gaps = NULL;
+ bfd_size_type max_gap = 0;
if (!bfd_set_format (obfd, bfd_get_format (ibfd)))
{
bfd_get_filename(ibfd), bfd_get_target(ibfd),
bfd_get_filename(obfd), bfd_get_target(obfd));
- if (!bfd_set_start_address (obfd, bfd_get_start_address (ibfd))
+ if (set_start_set)
+ start = set_start;
+ else
+ start = bfd_get_start_address (ibfd);
+ start += adjust_start;
+
+ if (!bfd_set_start_address (obfd, start)
|| !bfd_set_file_flags (obfd,
(bfd_get_file_flags (ibfd)
& bfd_applicable_file_flags (obfd))))
if (osympp != isympp)
free (osympp);
- /* Allow the BFD backend to copy any private data it understands
- from the input BFD to the output BFD. */
- if (!bfd_copy_private_bfd_data (ibfd, obfd))
- {
- fprintf (stderr, "%s: %s: error copying private BFD data: %s\n",
- program_name, bfd_get_filename (obfd),
- bfd_errmsg (bfd_get_error ()));
- status = 1;
- return;
- }
-
/* bfd mandates that all output sections be created and sizes set before
any output is done. Thus, we traverse all sections multiple times. */
bfd_map_over_sections (ibfd, setup_section, (void *) obfd);
+ if (add_sections != NULL)
+ {
+ struct section_add *padd;
+ struct section_list *pset;
+
+ for (padd = add_sections; padd != NULL; padd = padd->next)
+ {
+ padd->section = bfd_make_section (obfd, padd->name);
+ if (padd->section == NULL)
+ {
+ fprintf (stderr, "%s: can't create section `%s': %s\n",
+ program_name, padd->name,
+ bfd_errmsg (bfd_get_error ()));
+ status = 1;
+ return;
+ }
+ else
+ {
+ flagword flags;
+
+ if (! bfd_set_section_size (obfd, padd->section, padd->size))
+ nonfatal (bfd_get_filename (obfd));
+
+ pset = find_section_list (padd->name, false);
+ if (pset != NULL)
+ pset->used = true;
+
+ if (pset != NULL && pset->set_flags)
+ flags = pset->flags | SEC_HAS_CONTENTS;
+ else
+ flags = SEC_HAS_CONTENTS | SEC_READONLY | SEC_DATA;
+ if (! bfd_set_section_flags (obfd, padd->section, flags))
+ nonfatal (bfd_get_filename (obfd));
+
+ if (pset != NULL
+ && (pset->adjust == adjust_vma
+ || pset->adjust == set_vma))
+ {
+ if (! bfd_set_section_vma (obfd, padd->section, pset->val))
+ nonfatal (bfd_get_filename (obfd));
+ }
+ }
+ }
+ }
+
+ if (gap_fill_set || pad_to_set)
+ {
+ asection **set;
+ unsigned int c, i;
+
+ /* We must fill in gaps between the sections and/or we must pad
+ the last section to a specified address. We do this by
+ grabbing a list of the sections, sorting them by VMA, and
+ increasing the section sizes as required to fill the gaps.
+ We write out the gap contents below. */
+
+ c = bfd_count_sections (obfd);
+ osections = (asection **) xmalloc (c * sizeof (asection *));
+ set = osections;
+ bfd_map_over_sections (obfd, get_sections, (void *) &set);
+
+ qsort (osections, c, sizeof (asection *), compare_section_vma);
+
+ gaps = (bfd_size_type *) xmalloc (c * sizeof (bfd_size_type));
+ memset (gaps, 0, c * sizeof (bfd_size_type));
+
+ if (gap_fill_set)
+ {
+ for (i = 0; i < c - 1; i++)
+ {
+ flagword flags;
+ bfd_size_type size;
+ bfd_vma gap_start, gap_stop;
+
+ flags = bfd_get_section_flags (obfd, osections[i]);
+ if ((flags & SEC_HAS_CONTENTS) == 0
+ || (flags & SEC_LOAD) == 0)
+ continue;
+
+ size = bfd_section_size (obfd, osections[i]);
+ gap_start = bfd_section_vma (obfd, osections[i]) + size;
+ gap_stop = bfd_section_vma (obfd, osections[i + 1]);
+ if (gap_start < gap_stop)
+ {
+ if (! bfd_set_section_size (obfd, osections[i],
+ size + (gap_stop - gap_start)))
+ {
+ fprintf (stderr, "%s: Can't fill gap after %s: %s\n",
+ program_name,
+ bfd_get_section_name (obfd, osections[i]),
+ bfd_errmsg (bfd_get_error()));
+ status = 1;
+ break;
+ }
+ gaps[i] = gap_stop - gap_start;
+ if (max_gap < gap_stop - gap_start)
+ max_gap = gap_stop - gap_start;
+ }
+ }
+ }
+
+ if (pad_to_set)
+ {
+ bfd_vma vma;
+ bfd_size_type size;
+
+ vma = bfd_section_vma (obfd, osections[c - 1]);
+ size = bfd_section_size (obfd, osections[c - 1]);
+ if (vma + size < pad_to)
+ {
+ if (! bfd_set_section_size (obfd, osections[c - 1],
+ pad_to - vma))
+ {
+ fprintf (stderr, "%s: Can't add padding to %s: %s\n",
+ program_name,
+ bfd_get_section_name (obfd, osections[c - 1]),
+ bfd_errmsg (bfd_get_error ()));
+ status = 1;
+ }
+ else
+ {
+ gaps[c - 1] = pad_to - (vma + size);
+ if (max_gap < pad_to - (vma + size))
+ max_gap = pad_to - (vma + size);
+ }
+ }
+ }
+ }
+
/* Symbol filtering must happen after the output sections have
been created, but before their contents are set. */
- if (strip_symbols == strip_all && discard_locals == locals_undef)
+ if (strip_symbols == strip_all)
{
osympp = isympp = NULL;
symcount = 0;
else
{
long symsize;
+ PTR dhandle = NULL;
symsize = bfd_get_symtab_upper_bound (ibfd);
if (symsize < 0)
nonfatal (bfd_get_filename (ibfd));
}
- if (strip_symbols == strip_debug || discard_locals != locals_undef)
+ if (convert_debugging)
+ dhandle = read_debugging_info (ibfd, isympp, symcount);
+
+ if (strip_symbols == strip_debug
+ || strip_symbols == strip_unneeded
+ || discard_locals != locals_undef
+ || strip_specific_list != NULL
+ || sections_removed
+ || convert_debugging)
{
/* Mark symbols used in output relocations so that they
are kept, even if they are local labels or static symbols.
section. */
bfd_map_over_sections (ibfd,
mark_symbols_used_in_relocations,
- (void *)isympp);
+ (PTR)isympp);
osympp = (asymbol **) xmalloc (symcount * sizeof (asymbol *));
symcount = filter_symbols (ibfd, osympp, isympp, symcount);
}
+
+ if (convert_debugging && dhandle != NULL)
+ {
+ if (! write_debugging_info (obfd, dhandle, &symcount, &osympp))
+ {
+ status = 1;
+ return;
+ }
+ }
}
bfd_set_symtab (obfd, osympp, symcount);
/* This has to happen after the symbol table has been set. */
bfd_map_over_sections (ibfd, copy_section, (void *) obfd);
+
+ if (add_sections != NULL)
+ {
+ struct section_add *padd;
+
+ for (padd = add_sections; padd != NULL; padd = padd->next)
+ {
+ if (! bfd_set_section_contents (obfd, padd->section,
+ (PTR) padd->contents,
+ (file_ptr) 0,
+ (bfd_size_type) padd->size))
+ nonfatal (bfd_get_filename (obfd));
+ }
+ }
+
+ if (gap_fill_set || pad_to_set)
+ {
+ bfd_byte *buf;
+ int c, i;
+
+ /* Fill in the gaps. */
+
+ if (max_gap > 8192)
+ max_gap = 8192;
+ buf = (bfd_byte *) xmalloc (max_gap);
+ memset (buf, gap_fill, (size_t) max_gap);
+
+ c = bfd_count_sections (obfd);
+ for (i = 0; i < c; i++)
+ {
+ if (gaps[i] != 0)
+ {
+ bfd_size_type left;
+ file_ptr off;
+
+ left = gaps[i];
+ off = bfd_section_size (obfd, osections[i]) - left;
+ while (left > 0)
+ {
+ bfd_size_type now;
+
+ if (left > 8192)
+ now = 8192;
+ else
+ now = left;
+ if (! bfd_set_section_contents (obfd, osections[i], buf,
+ off, now))
+ {
+ nonfatal (bfd_get_filename (obfd));
+ }
+ left -= now;
+ off += now;
+ }
+ }
+ }
+ }
+
+ /* Allow the BFD backend to copy any private data it understands
+ from the input BFD to the output BFD. This is done last to
+ permit the routine to look at the filtered symbol table, which is
+ important for the ECOFF code at least. */
+ if (!bfd_copy_private_bfd_data (ibfd, obfd))
+ {
+ fprintf (stderr, "%s: %s: error copying private BFD data: %s\n",
+ program_name, bfd_get_filename (obfd),
+ bfd_errmsg (bfd_get_error ()));
+ status = 1;
+ return;
+ }
}
static char *
bfd *obfd;
char *output_target;
{
+ struct name_list
+ {
+ struct name_list *next;
+ char *name;
+ bfd *obfd;
+ } *list, *l;
bfd **ptr = &obfd->archive_head;
bfd *this_element;
- char *dir = cat ("./#", make_tempname (""), "cd");
+ char *dir = make_tempname (bfd_get_filename (obfd));
/* Make a temp directory to hold the contents. */
- mkdir (dir, 0777);
+ if (mkdir (dir, 0700) != 0)
+ {
+ fatal ("cannot mkdir %s for archive copying (error: %s)",
+ dir, strerror (errno));
+ }
obfd->has_armap = ibfd->has_armap;
+ list = NULL;
+
this_element = bfd_openr_next_archived_file (ibfd, NULL);
- ibfd->archive_head = this_element;
while (this_element != (bfd *) NULL)
{
/* Create an output file for this member. */
char *output_name = cat (dir, "/", bfd_get_filename(this_element));
bfd *output_bfd = bfd_openw (output_name, output_target);
+ bfd *last_element;
+
+ l = (struct name_list *) xmalloc (sizeof (struct name_list));
+ l->name = output_name;
+ l->next = list;
+ list = l;
if (output_bfd == (bfd *) NULL)
{
}
bfd_close (output_bfd);
- /* Open the newly output file and attatch to our list. */
+
+ /* Open the newly output file and attach to our list. */
output_bfd = bfd_openr (output_name, output_target);
- /* Mark it for deletion. */
+ l->obfd = output_bfd;
+
*ptr = output_bfd;
ptr = &output_bfd->next;
- this_element->next = bfd_openr_next_archived_file (ibfd, this_element);
- this_element = this_element->next;
+
+ last_element = this_element;
+
+ this_element = bfd_openr_next_archived_file (ibfd, last_element);
+
+ bfd_close (last_element);
}
*ptr = (bfd *) NULL;
nonfatal (bfd_get_filename (obfd));
}
- /* Delete all the files that we opened.
- Construct their names again, unfortunately, but
- we're about to exit anyway. */
- for (this_element = ibfd->archive_head;
- this_element != (bfd *) NULL;
- this_element = this_element->next)
- {
- unlink (cat (dir, "/", bfd_get_filename (this_element)));
- }
- rmdir (dir);
if (!bfd_close (ibfd))
{
nonfatal (bfd_get_filename (ibfd));
}
+
+ /* Delete all the files that we opened. */
+ for (l = list; l != NULL; l = l->next)
+ {
+ bfd_close (l->obfd);
+ unlink (l->name);
+ }
+ rmdir (dir);
}
/* The top-level control. */
if (bfd_check_format (ibfd, bfd_archive))
{
- bfd *obfd = bfd_openw (output_filename, output_target);
+ bfd *obfd;
+
+ /* bfd_get_target does not return the correct value until
+ bfd_check_format succeeds. */
+ if (output_target == NULL)
+ output_target = bfd_get_target (ibfd);
+
+ obfd = bfd_openw (output_filename, output_target);
if (obfd == NULL)
{
nonfatal (output_filename);
}
else if (bfd_check_format_matches (ibfd, bfd_object, &matching))
{
- bfd *obfd = bfd_openw (output_filename, output_target);
+ bfd *obfd;
+
+ /* bfd_get_target does not return the correct value until
+ bfd_check_format succeeds. */
+ if (output_target == NULL)
+ output_target = bfd_get_target (ibfd);
+
+ obfd = bfd_openw (output_filename, output_target);
if (obfd == NULL)
{
nonfatal (output_filename);
as ISECTION in IBFD. */
static void
-setup_section (ibfd, isection, obfd)
+setup_section (ibfd, isection, obfdarg)
bfd *ibfd;
sec_ptr isection;
- bfd *obfd;
+ PTR obfdarg;
{
+ bfd *obfd = (bfd *) obfdarg;
+ struct section_list *p;
sec_ptr osection;
+ bfd_vma vma;
+ bfd_vma lma;
+ flagword flags;
char *err;
if ((bfd_get_section_flags (ibfd, isection) & SEC_DEBUGGING) != 0
&& (strip_symbols == strip_debug
+ || strip_symbols == strip_unneeded
|| strip_symbols == strip_all
- || discard_locals == locals_all))
+ || discard_locals == locals_all
+ || convert_debugging))
+ return;
+
+ p = find_section_list (bfd_section_name (ibfd, isection), false);
+ if (p != NULL)
+ p->used = true;
+
+ if (p != NULL && p->remove)
return;
osection = bfd_make_section_anyway (obfd, bfd_section_name (ibfd, isection));
goto loser;
}
- if (bfd_set_section_vma (obfd,
- osection,
- bfd_section_vma (ibfd, isection))
- == false)
+ vma = bfd_section_vma (ibfd, isection);
+ if (p != NULL && p->adjust == adjust_vma)
+ vma += p->val;
+ else if (p != NULL && p->adjust == set_vma)
+ vma = p->val;
+ else
+ vma += adjust_section_vma;
+ if (! bfd_set_section_vma (obfd, osection, vma))
{
err = "vma";
goto loser;
}
+ lma = isection->lma;
+ if (p != NULL && p->adjust == adjust_vma)
+ lma += p->val;
+ else if (p != NULL && p->adjust == set_vma)
+ lma = p->val;
+ else
+ lma += adjust_section_vma;
+ osection->lma = lma;
+
if (bfd_set_section_alignment (obfd,
osection,
bfd_section_alignment (ibfd, isection))
goto loser;
}
- if (!bfd_set_section_flags (obfd, osection,
- bfd_get_section_flags (ibfd, isection)))
+ flags = bfd_get_section_flags (ibfd, isection);
+ if (p != NULL && p->set_flags)
+ flags = p->flags | (flags & SEC_HAS_CONTENTS);
+ if (!bfd_set_section_flags (obfd, osection, flags))
{
err = "flags";
goto loser;
If stripping then don't copy any relocation info. */
static void
-copy_section (ibfd, isection, obfd)
+copy_section (ibfd, isection, obfdarg)
bfd *ibfd;
sec_ptr isection;
- bfd *obfd;
+ PTR obfdarg;
{
+ bfd *obfd = (bfd *) obfdarg;
+ struct section_list *p;
arelent **relpp;
long relcount;
sec_ptr osection;
if ((bfd_get_section_flags (ibfd, isection) & SEC_DEBUGGING) != 0
&& (strip_symbols == strip_debug
+ || strip_symbols == strip_unneeded
|| strip_symbols == strip_all
- || discard_locals == locals_all))
+ || discard_locals == locals_all
+ || convert_debugging))
{
return;
}
+ p = find_section_list (bfd_section_name (ibfd, isection), false);
+
+ if (p != NULL && p->remove)
+ return;
+
osection = isection->output_section;
size = bfd_get_section_size_before_reloc (isection);
nonfatal (bfd_get_filename (ibfd));
}
- if (copy_byte >= 0)
- filter_bytes (memhunk, &size);
+ if (copy_byte >= 0)
+ {
+ filter_bytes (memhunk, &size);
+ /* The section has gotten smaller. */
+ if (!bfd_set_section_size (obfd, osection, size))
+ nonfatal (bfd_get_filename (obfd));
+ }
if (!bfd_set_section_contents (obfd, osection, memhunk, (file_ptr) 0,
size))
}
}
+/* Get all the sections. This is used when --gap-fill or --pad-to is
+ used. */
+
+static void
+get_sections (obfd, osection, secppparg)
+ bfd *obfd;
+ asection *osection;
+ PTR secppparg;
+{
+ asection ***secppp = (asection ***) secppparg;
+
+ **secppp = osection;
+ ++(*secppp);
+}
+
+/* Sort sections by VMA. This is called via qsort, and is used when
+ --gap-fill or --pad-to is used. We force non loadable or empty
+ sections to the front, where they are easier to ignore. */
+
+static int
+compare_section_vma (arg1, arg2)
+ const PTR arg1;
+ const PTR arg2;
+{
+ const asection **sec1 = (const asection **) arg1;
+ const asection **sec2 = (const asection **) arg2;
+ flagword flags1, flags2;
+
+ /* Sort non loadable sections to the front. */
+ flags1 = (*sec1)->flags;
+ flags2 = (*sec2)->flags;
+ if ((flags1 & SEC_HAS_CONTENTS) == 0
+ || (flags1 & SEC_LOAD) == 0)
+ {
+ if ((flags2 & SEC_HAS_CONTENTS) != 0
+ && (flags2 & SEC_LOAD) != 0)
+ return -1;
+ }
+ else
+ {
+ if ((flags2 & SEC_HAS_CONTENTS) == 0
+ || (flags2 & SEC_LOAD) == 0)
+ return 1;
+ }
+
+ /* Sort sections by VMA. */
+ if ((*sec1)->vma > (*sec2)->vma)
+ return 1;
+ else if ((*sec1)->vma < (*sec2)->vma)
+ return -1;
+
+ /* Sort sections with the same VMA by size. */
+ if ((*sec1)->_raw_size > (*sec2)->_raw_size)
+ return 1;
+ else if ((*sec1)->_raw_size < (*sec2)->_raw_size)
+ return -1;
+
+ return 0;
+}
+
/* Mark all the symbols which will be used in output relocations with
the BSF_KEEP flag so that those symbols will not be stripped.
Ignore relocations which will not appear in the output file. */
static void
-mark_symbols_used_in_relocations (ibfd, isection, symbols)
+mark_symbols_used_in_relocations (ibfd, isection, symbolsarg)
bfd *ibfd;
sec_ptr isection;
- asymbol **symbols;
+ PTR symbolsarg;
{
+ asymbol **symbols = (asymbol **) symbolsarg;
long relsize;
arelent **relpp;
long relcount, i;
if (relsize < 0)
bfd_fatal (bfd_get_filename (ibfd));
+ if (relsize == 0)
+ return;
+
relpp = (arelent **) xmalloc (relsize);
relcount = bfd_canonicalize_reloc (ibfd, isection, relpp, symbols);
if (relcount < 0)
special bfd section symbols, then mark it with BSF_KEEP. */
for (i = 0; i < relcount; i++)
{
- if (*relpp[i]->sym_ptr_ptr != bfd_com_section.symbol
- && *relpp[i]->sym_ptr_ptr != bfd_abs_section.symbol
- && *relpp[i]->sym_ptr_ptr != bfd_und_section.symbol)
+ if (*relpp[i]->sym_ptr_ptr != bfd_com_section_ptr->symbol
+ && *relpp[i]->sym_ptr_ptr != bfd_abs_section_ptr->symbol
+ && *relpp[i]->sym_ptr_ptr != bfd_und_section_ptr->symbol)
(*relpp[i]->sym_ptr_ptr)->flags |= BSF_KEEP;
}
free (relpp);
}
+/* Write out debugging information. */
+
+static boolean
+write_debugging_info (obfd, dhandle, symcountp, symppp)
+ bfd *obfd;
+ PTR dhandle;
+ long *symcountp;
+ asymbol ***symppp;
+{
+ if (bfd_get_flavour (obfd) == bfd_target_ieee_flavour)
+ return write_ieee_debugging_info (obfd, dhandle);
+
+ fprintf (stderr,
+ "%s: don't know how to write debugging information for %s\n",
+ bfd_get_filename (obfd), bfd_get_target (obfd));
+ return false;
+}
+
/* The number of bytes to copy at once. */
#define COPY_BUF 8192
char *from, *to;
{
int fromfd, tofd, nread;
+ int saved;
char buf[COPY_BUF];
fromfd = open (from, O_RDONLY);
if (fromfd < 0)
return -1;
- tofd = open (to, O_WRONLY | O_CREAT | O_TRUNC);
+ tofd = creat (to, 0777);
if (tofd < 0)
{
+ saved = errno;
close (fromfd);
+ errno = saved;
return -1;
}
while ((nread = read (fromfd, buf, sizeof buf)) > 0)
{
if (write (tofd, buf, nread) != nread)
{
+ saved = errno;
close (fromfd);
close (tofd);
+ errno = saved;
return -1;
}
}
+ saved = errno;
close (fromfd);
close (tofd);
if (nread < 0)
- return -1;
+ {
+ errno = saved;
+ return -1;
+ }
return 0;
}
chmod (to, s.st_mode & 07777);
chown (to, s.st_uid, s.st_gid);
}
+ else
+ {
+ /* We have to clean up here. */
+ int saved = errno;
+ fprintf (stderr, "%s: %s: ", program_name, to);
+ errno = saved;
+ perror ("rename");
+ unlink (from);
+ }
}
else
{
ret = simple_copy (from, to);
- if (ret == 0)
- unlink (from);
+ if (ret != 0)
+ {
+ int saved = errno;
+ fprintf (stderr, "%s: %s: ", program_name, to);
+ errno = saved;
+ perror ("simple_copy");
+ }
+ unlink (from);
}
return ret;
}
char *input_target = NULL, *output_target = NULL;
boolean show_version = false;
int c, i;
+ struct section_list *p;
- while ((c = getopt_long (argc, argv, "I:O:F:sSgxXVv",
+ while ((c = getopt_long (argc, argv, "I:O:F:K:N:R:sSgxXVv",
strip_options, (int *) 0)) != EOF)
{
switch (c)
case 'F':
input_target = output_target = optarg;
break;
+ case 'R':
+ p = find_section_list (optarg, true);
+ p->remove = true;
+ sections_removed = true;
+ break;
case 's':
strip_symbols = strip_all;
break;
case 'g':
strip_symbols = strip_debug;
break;
+ case OPTION_STRIP_UNNEEDED:
+ strip_symbols = strip_unneeded;
+ break;
+ case 'K':
+ if (! keep_symbols && strip_specific_list != NULL)
+ {
+ fprintf (stderr, "%s: Can not specify both -K and -N\n",
+ program_name);
+ strip_usage (stderr, 1);
+ }
+ keep_symbols = true;
+ add_strip_symbol (optarg);
+ break;
+ case 'N':
+ if (keep_symbols)
+ {
+ fprintf (stderr, "%s: Can not specify both -K and -N\n",
+ program_name);
+ strip_usage (stderr, 1);
+ }
+ add_strip_symbol (optarg);
+ break;
case 'x':
discard_locals = locals_all;
break;
}
/* Default is to strip all symbols. */
- if (strip_symbols == strip_undef && discard_locals == locals_undef)
+ if (strip_symbols == strip_undef
+ && discard_locals == locals_undef
+ && strip_specific_list == NULL)
strip_symbols = strip_all;
if (output_target == (char *) NULL)
int argc;
char *argv[];
{
- char *input_filename, *output_filename;
+ char *input_filename = NULL, *output_filename = NULL;
char *input_target = NULL, *output_target = NULL;
boolean show_version = false;
+ boolean adjust_warn = true;
int c;
+ struct section_list *p;
- while ((c = getopt_long (argc, argv, "b:i:I:s:O:d:F:SgxXVv",
+ while ((c = getopt_long (argc, argv, "b:i:I:K:N:s:O:d:F:R:SgxXVv",
copy_options, (int *) 0)) != EOF)
{
switch (c)
case 'F':
input_target = output_target = optarg;
break;
+ case 'R':
+ p = find_section_list (optarg, true);
+ p->remove = true;
+ sections_removed = true;
+ break;
case 'S':
strip_symbols = strip_all;
break;
case 'g':
strip_symbols = strip_debug;
break;
+ case OPTION_STRIP_UNNEEDED:
+ strip_symbols = strip_unneeded;
+ break;
+ case 'K':
+ if (! keep_symbols && strip_specific_list != NULL)
+ {
+ fprintf (stderr, "%s: Can not specify both -K and -N\n",
+ program_name);
+ strip_usage (stderr, 1);
+ }
+ keep_symbols = true;
+ add_strip_symbol (optarg);
+ break;
+ case 'N':
+ if (keep_symbols)
+ {
+ fprintf (stderr, "%s: Can not specify both -K and -N\n",
+ program_name);
+ strip_usage (stderr, 1);
+ }
+ add_strip_symbol (optarg);
+ break;
case 'x':
discard_locals = locals_all;
break;
case 'V':
show_version = true;
break;
+ case OPTION_ADD_SECTION:
+ {
+ const char *s;
+ struct stat st;
+ struct section_add *pa;
+ int len;
+ char *name;
+ FILE *f;
+
+ s = strchr (optarg, '=');
+ if (s == NULL)
+ {
+ fprintf (stderr,
+ "%s: bad format for --add-section NAME=FILENAME\n",
+ program_name);
+ exit (1);
+ }
+
+ if (stat (s + 1, &st) < 0)
+ {
+ fprintf (stderr, "%s: ", program_name);
+ perror (s + 1);
+ exit (1);
+ }
+
+ pa = (struct section_add *) xmalloc (sizeof (struct section_add));
+
+ len = s - optarg;
+ name = (char *) xmalloc (len + 1);
+ strncpy (name, optarg, len);
+ name[len] = '\0';
+ pa->name = name;
+
+ pa->filename = s + 1;
+
+ pa->size = st.st_size;
+
+ pa->contents = (bfd_byte *) xmalloc (pa->size);
+ f = fopen (pa->filename, FOPEN_RB);
+ if (f == NULL)
+ {
+ fprintf (stderr, "%s: ", program_name);
+ perror (pa->filename);
+ exit (1);
+ }
+ if (fread (pa->contents, 1, pa->size, f) == 0
+ || ferror (f))
+ {
+ fprintf (stderr, "%s: %s: fread failed\n",
+ program_name, pa->filename);
+ exit (1);
+ }
+ fclose (f);
+
+ pa->next = add_sections;
+ add_sections = pa;
+ }
+ break;
+ case OPTION_ADJUST_START:
+ adjust_start = parse_vma (optarg, "--adjust-start");
+ break;
+ case OPTION_ADJUST_SECTION_VMA:
+ {
+ const char *s;
+ int len;
+ char *name;
+
+ s = strchr (optarg, '=');
+ if (s == NULL)
+ {
+ s = strchr (optarg, '+');
+ if (s == NULL)
+ {
+ s = strchr (optarg, '-');
+ if (s == NULL)
+ {
+ fprintf (stderr,
+ "%s: bad format for --adjust-section-vma\n",
+ program_name);
+ exit (1);
+ }
+ }
+ }
+
+ len = s - optarg;
+ name = (char *) xmalloc (len + 1);
+ strncpy (name, optarg, len);
+ name[len] = '\0';
+
+ p = find_section_list (name, true);
+
+ p->val = parse_vma (s + 1, "--adjust-section-vma");
+
+ if (*s == '=')
+ p->adjust = set_vma;
+ else
+ {
+ p->adjust = adjust_vma;
+ if (*s == '-')
+ p->val = - p->val;
+ }
+ }
+ break;
+ case OPTION_ADJUST_VMA:
+ adjust_section_vma = parse_vma (optarg, "--adjust-vma");
+ adjust_start = adjust_section_vma;
+ break;
+ case OPTION_ADJUST_WARNINGS:
+ adjust_warn = true;
+ break;
+ case OPTION_DEBUGGING:
+ convert_debugging = true;
+ break;
+ case OPTION_GAP_FILL:
+ {
+ bfd_vma gap_fill_vma;
+
+ gap_fill_vma = parse_vma (optarg, "--gap-fill");
+ gap_fill = (bfd_byte) gap_fill_vma;
+ if ((bfd_vma) gap_fill != gap_fill_vma)
+ {
+ fprintf (stderr, "%s: warning: truncating gap-fill from 0x",
+ program_name);
+ fprintf_vma (stderr, gap_fill_vma);
+ fprintf (stderr, "to 0x%x\n", (unsigned int) gap_fill);
+ }
+ gap_fill_set = true;
+ }
+ break;
+ case OPTION_NO_ADJUST_WARNINGS:
+ adjust_warn = false;
+ break;
+ case OPTION_PAD_TO:
+ pad_to = parse_vma (optarg, "--pad-to");
+ pad_to_set = true;
+ break;
+ case OPTION_SET_SECTION_FLAGS:
+ {
+ const char *s;
+ int len;
+ char *name;
+
+ s = strchr (optarg, '=');
+ if (s == NULL)
+ {
+ fprintf (stderr, "%s: bad format for --set-section-flags\n",
+ program_name);
+ exit (1);
+ }
+
+ len = s - optarg;
+ name = (char *) xmalloc (len + 1);
+ strncpy (name, optarg, len);
+ name[len] = '\0';
+
+ p = find_section_list (name, true);
+
+ p->set_flags = true;
+ p->flags = parse_flags (s + 1);
+ }
+ break;
+ case OPTION_SET_START:
+ set_start = parse_vma (optarg, "--set-start");
+ set_start_set = true;
+ break;
case 0:
break; /* we've been given a long option */
case 'h':
copy_file (input_filename, output_filename, input_target, output_target);
}
+ if (adjust_warn)
+ {
+ for (p = adjust_sections; p != NULL; p = p->next)
+ {
+ if (! p->used && p->adjust != ignore_vma)
+ {
+ fprintf (stderr, "%s: warning: --adjust-section-vma %s%c0x",
+ program_name, p->name,
+ p->adjust == set_vma ? '=' : '+');
+ fprintf_vma (stderr, p->val);
+ fprintf (stderr, " never used\n");
+ }
+ }
+ }
+
return 0;
}
{
program_name = argv[0];
xmalloc_set_program_name (program_name);
+
+ START_PROGRESS (program_name, 0);
+
strip_symbols = strip_undef;
discard_locals = locals_undef;
if (is_strip < 0)
{
int i = strlen (program_name);
- is_strip = (i >= 5 && strcmp (program_name + i - 5, "strip"));
+ is_strip = (i >= 5 && strcmp (program_name + i - 5, "strip") == 0);
}
if (is_strip)
else
copy_main (argc, argv);
+ END_PROGRESS (program_name);
+
return status;
}
projects / binutils.git / blobdiff