/* 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, 96, 97, 1998
+ 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ 02111-1307, USA. */
\f
#include "bfd.h"
#include "progress.h"
#include "bucomm.h"
-#include <getopt.h>
+#include "getopt.h"
#include "libiberty.h"
+#include "budbg.h"
#include <sys/stat.h>
+#ifdef HAVE_GOOD_UTIME_H
+#include <utime.h>
+#else /* ! HAVE_GOOD_UTIME_H */
+#ifdef HAVE_UTIMES
+#include <sys/time.h>
+#endif /* HAVE_UTIMES */
+#endif /* ! HAVE_GOOD_UTIME_H */
+
+/* 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;
+};
+
+static void copy_usage PARAMS ((FILE *, int));
+static void strip_usage PARAMS ((FILE *, int));
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 void add_specific_symbol PARAMS ((const char *, struct symlist **));
+static boolean is_specified_symbol PARAMS ((const char *, struct symlist *));
static boolean is_strip_section PARAMS ((bfd *, asection *));
static unsigned int filter_symbols
- PARAMS ((bfd *, asymbol **, asymbol **, long));
+ PARAMS ((bfd *, bfd *, asymbol **, asymbol **, long));
static void mark_symbols_used_in_relocations PARAMS ((bfd *, asection *, PTR));
+static void filter_bytes PARAMS ((char *, bfd_size_type *));
+static boolean write_debugging_info PARAMS ((bfd *, PTR, long *, asymbol ***));
+static void copy_object PARAMS ((bfd *, bfd *));
+static void copy_archive PARAMS ((bfd *, bfd *, const char *));
+static void copy_file
+ PARAMS ((const char *, const char *, const char *, const char *));
+static int simple_copy PARAMS ((const char *, const char *));
+static int smart_rename PARAMS ((const char *, const char *));
+static void set_times PARAMS ((const char *, const struct stat *));
+static int strip_main PARAMS ((int, char **));
+static int copy_main PARAMS ((int, char **));
#define nonfatal(s) {bfd_nonfatal(s); status = 1; return;}
static struct section_add *add_sections;
+/* Whether to convert debugging information. */
+
+static boolean convert_debugging = false;
+
+/* Whether to change the leading character in symbol names. */
+
+static boolean change_leading_char = false;
+
+/* Whether to remove the leading character from global symbol names. */
+
+static boolean remove_leading_char = false;
+
+/* List of symbols to strip, keep, localize, and weaken. */
+
+static struct symlist *strip_specific_list = NULL;
+static struct symlist *keep_specific_list = NULL;
+static struct symlist *localize_specific_list = NULL;
+static struct symlist *weaken_specific_list = NULL;
+
+/* If this is true, we weaken global symbols (set BSF_WEAK). */
+
+static boolean weaken = false;
+
/* 150 isn't special; it's just an arbitrary non-ASCII char value. */
#define OPTION_ADD_SECTION 150
#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_GAP_FILL (OPTION_ADJUST_WARNINGS + 1)
+#define OPTION_CHANGE_LEADING_CHAR (OPTION_ADJUST_WARNINGS + 1)
+#define OPTION_DEBUGGING (OPTION_CHANGE_LEADING_CHAR + 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_REMOVE_LEADING_CHAR (OPTION_PAD_TO + 1)
+#define OPTION_SET_SECTION_FLAGS (OPTION_REMOVE_LEADING_CHAR + 1)
#define OPTION_SET_START (OPTION_SET_SECTION_FLAGS + 1)
#define OPTION_STRIP_UNNEEDED (OPTION_SET_START + 1)
+#define OPTION_WEAKEN (OPTION_STRIP_UNNEEDED + 1)
/* Options to handle if running as "strip". */
{"keep-symbol", required_argument, 0, 'K'},
{"output-format", required_argument, 0, 'O'}, /* Obsolete */
{"output-target", required_argument, 0, 'O'},
+ {"preserve-dates", no_argument, 0, 'p'},
{"remove-section", required_argument, 0, 'R'},
{"strip-all", no_argument, 0, 's'},
{"strip-debug", no_argument, 0, 'S'},
{"adjust-section-vma", required_argument, 0, OPTION_ADJUST_SECTION_VMA},
{"adjust-warnings", no_argument, 0, OPTION_ADJUST_WARNINGS},
{"byte", required_argument, 0, 'b'},
+ {"change-leading-char", no_argument, 0, OPTION_CHANGE_LEADING_CHAR},
+ {"debugging", no_argument, 0, OPTION_DEBUGGING},
{"discard-all", no_argument, 0, 'x'},
{"discard-locals", no_argument, 0, 'X'},
{"format", required_argument, 0, 'F'}, /* Obsolete */
{"output-format", required_argument, 0, 'O'}, /* Obsolete */
{"output-target", required_argument, 0, 'O'},
{"pad-to", required_argument, 0, OPTION_PAD_TO},
+ {"preserve-dates", no_argument, 0, 'p'},
+ {"localize-symbol", required_argument, 0, 'L'},
+ {"remove-leading-char", no_argument, 0, OPTION_REMOVE_LEADING_CHAR},
{"remove-section", required_argument, 0, 'R'},
{"set-section-flags", required_argument, 0, OPTION_SET_SECTION_FLAGS},
{"set-start", required_argument, 0, OPTION_SET_START},
{"target", required_argument, 0, 'F'},
{"verbose", no_argument, 0, 'v'},
{"version", no_argument, 0, 'V'},
+ {"weaken", no_argument, 0, OPTION_WEAKEN},
+ {"weaken-symbol", required_argument, 0, 'W'},
{0, no_argument, 0, 0}
};
/* IMPORTS */
extern char *program_name;
-extern char *program_version;
/* This flag distinguishes between strip and objcopy:
1 means this is 'strip'; 0 means this is 'objcopy'.
int exit_status;
{
fprintf (stream, "\
-Usage: %s [-vVSgxX] [-I bfdname] [-O bfdname] [-F bfdname] [-b byte]\n\
+Usage: %s [-vVSpgxX] [-I bfdname] [-O bfdname] [-F bfdname] [-b byte]\n\
[-R section] [-i interleave] [--interleave=interleave] [--byte=byte]\n\
[--input-target=bfdname] [--output-target=bfdname] [--target=bfdname]\n\
[--strip-all] [--strip-debug] [--strip-unneeded] [--discard-all]\n\
- [--discard-locals] [--remove-section=section] [--gap-fill=val]\n",
+ [--discard-locals] [--debugging] [--remove-section=section]\n",
program_name);
fprintf (stream, "\
- [--pad-to=address] [--set-start=val] [--adjust-start=incr]\n\
+ [--gap-fill=val] [--pad-to=address] [--preserve-dates]\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");
+ [--localize-symbol symbol] [-L symbol] [--weaken-symbol symbol]\n\
+ [-W symbol] [--change-leading-char] [--remove-leading-char] [--weaken]\n\
+ [--verbose] [--version] [--help] in-file [out-file]\n");
list_supported_targets (program_name, stream);
+ if (exit_status == 0)
+ fprintf (stream, "Report bugs to bug-gnu-utils@gnu.org\n");
exit (exit_status);
}
int exit_status;
{
fprintf (stream, "\
-Usage: %s [-vVsSgxX] [-I bfdname] [-O bfdname] [-F bfdname] [-R section]\n\
+Usage: %s [-vVsSpgxX] [-I bfdname] [-O bfdname] [-F bfdname] [-R section]\n\
[--input-target=bfdname] [--output-target=bfdname] [--target=bfdname]\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",
+ [-o file] [--preserve-dates] [--verbose] [--version] [--help] file...\n",
program_name);
list_supported_targets (program_name, stream);
+ if (exit_status == 0)
+ fprintf (stream, "Report bugs to bug-gnu-utils@gnu.org\n");
exit (exit_status);
}
++snext;
}
-#define PARSE_FLAG(fname,fval) if (strncmp (fname, s, len) == 0) ret |= fval;
+ if (0) ;
+#define PARSE_FLAG(fname,fval) \
+ else if (strncasecmp (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);
+ PARSE_FLAG ("contents", SEC_HAS_CONTENTS);
#undef PARSE_FLAG
+ else
+ {
+ char *copy;
+
+ copy = xmalloc (len + 1);
+ strncpy (copy, s, len);
+ copy[len] = '\0';
+ fprintf (stderr, "%s: unrecognized section flag `%s'\n",
+ program_name, copy);
+ fprintf (stderr,
+ "%s: supported flags: alloc, load, readonly, code, data, rom, contents\n",
+ program_name);
+ exit (1);
+ }
s = snext;
}
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)
+add_specific_symbol (name, list)
const char *name;
+ struct symlist **list;
{
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;
+ tmp_list->next = *list;
+ *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)
+is_specified_symbol (name, list)
const char *name;
+ struct symlist *list;
{
struct symlist *tmp_list;
- for (tmp_list = strip_specific_list; tmp_list; tmp_list = tmp_list->next)
+ for (tmp_list = list; tmp_list; tmp_list = tmp_list->next)
{
if (strcmp (name, tmp_list->name) == 0)
- return keep_symbols ? false : true;
+ return true;
}
- return keep_symbols;
+ return false;
}
/* See if a section is being removed. */
&& (strip_symbols == strip_debug
|| strip_symbols == strip_unneeded
|| strip_symbols == strip_all
- || discard_locals == locals_all))
+ || discard_locals == locals_all
+ || convert_debugging))
return true;
if (! sections_removed)
Return the number of symbols to print. */
static unsigned int
-filter_symbols (abfd, osyms, isyms, symcount)
+filter_symbols (abfd, obfd, osyms, isyms, symcount)
bfd *abfd;
+ bfd *obfd;
asymbol **osyms, **isyms;
long symcount;
{
{
asymbol *sym = from[src_count];
flagword flags = sym->flags;
+ const char *name = bfd_asymbol_name (sym);
int keep;
+ if (change_leading_char
+ && (bfd_get_symbol_leading_char (abfd)
+ != bfd_get_symbol_leading_char (obfd))
+ && (bfd_get_symbol_leading_char (abfd) == '\0'
+ || (name[0] == bfd_get_symbol_leading_char (abfd))))
+ {
+ if (bfd_get_symbol_leading_char (obfd) == '\0')
+ name = bfd_asymbol_name (sym) = name + 1;
+ else
+ {
+ char *n;
+
+ n = xmalloc (strlen (name) + 2);
+ n[0] = bfd_get_symbol_leading_char (obfd);
+ if (bfd_get_symbol_leading_char (abfd) == '\0')
+ strcpy (n + 1, name);
+ else
+ strcpy (n + 1, name + 1);
+ name = bfd_asymbol_name (sym) = n;
+ }
+ }
+
+ if (remove_leading_char
+ && ((flags & BSF_GLOBAL) != 0
+ || (flags & BSF_WEAK) != 0
+ || bfd_is_und_section (bfd_get_section (sym))
+ || bfd_is_com_section (bfd_get_section (sym)))
+ && name[0] == bfd_get_symbol_leading_char (abfd))
+ name = bfd_asymbol_name (sym) = name + 1;
+
if ((flags & BSF_KEEP) != 0) /* Used in relocation. */
keep = 1;
else if ((flags & BSF_GLOBAL) != 0 /* Global symbol. */
+ || (flags & BSF_WEAK) != 0
|| 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
- && strip_symbols != strip_unneeded);
+ && strip_symbols != strip_unneeded
+ && ! convert_debugging);
else /* Local symbol. */
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)))
+ if (keep && is_specified_symbol (name, strip_specific_list))
keep = 0;
+ if (!keep && is_specified_symbol (name, keep_specific_list))
+ keep = 1;
if (keep && is_strip_section (abfd, bfd_get_section (sym)))
keep = 0;
+ if (keep && (flags & BSF_GLOBAL) != 0
+ && (weaken || is_specified_symbol (name, weaken_specific_list)))
+ {
+ sym->flags &=~ BSF_GLOBAL;
+ sym->flags |= BSF_WEAK;
+ }
+ if (keep && (flags & (BSF_GLOBAL | BSF_WEAK))
+ && is_specified_symbol (name, localize_specific_list))
+ {
+ sym->flags &= ~(BSF_GLOBAL | BSF_WEAK);
+ sym->flags |= BSF_LOCAL;
+ }
+
if (keep)
to[dst_count++] = sym;
}
+ to[dst_count] = NULL;
+
return dst_count;
}
/* Keep only every `copy_byte'th byte in MEMHUNK, which is *SIZE bytes long.
Adjust *SIZE. */
-void
+static void
filter_bytes (memhunk, size)
char *memhunk;
bfd_size_type *size;
if (!bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
bfd_get_mach (ibfd)))
{
- fprintf (stderr, "Output file cannot represent architecture %s\n",
+ fprintf (stderr,
+ "Warning: Output file cannot represent architecture %s\n",
bfd_printable_arch_mach (bfd_get_arch (ibfd),
bfd_get_mach (ibfd)));
}
else
{
long symsize;
+ PTR dhandle = NULL;
symsize = bfd_get_symtab_upper_bound (ibfd);
if (symsize < 0)
nonfatal (bfd_get_filename (ibfd));
}
+ 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)
+ || keep_specific_list != NULL
+ || localize_specific_list != NULL
+ || weaken_specific_list != NULL
+ || sections_removed
+ || convert_debugging
+ || change_leading_char
+ || remove_leading_char
+ || weaken)
{
/* Mark symbols used in output relocations so that they
are kept, even if they are local labels or static symbols.
bfd_map_over_sections (ibfd,
mark_symbols_used_in_relocations,
(PTR)isympp);
- osympp = (asymbol **) xmalloc (symcount * sizeof (asymbol *));
- symcount = filter_symbols (ibfd, osympp, isympp, symcount);
+ osympp = (asymbol **) xmalloc ((symcount + 1) * sizeof (asymbol *));
+ symcount = filter_symbols (ibfd, obfd, osympp, isympp, symcount);
+ }
+
+ if (convert_debugging && dhandle != NULL)
+ {
+ if (! write_debugging_info (obfd, dhandle, &symcount, &osympp))
+ {
+ status = 1;
+ return;
+ }
}
}
}
}
-static char *
-cat (a, b, c)
- char *a;
- char *b;
- char *c;
-{
- size_t size = strlen (a) + strlen (b) + strlen (c);
- char *r = xmalloc (size + 1);
-
- strcpy (r, a);
- strcat (r, b);
- strcat (r, c);
- return r;
-}
-
/* Read each archive element in turn from IBFD, copy the
contents to temp file, and keep the temp file handle. */
copy_archive (ibfd, obfd, output_target)
bfd *ibfd;
bfd *obfd;
- char *output_target;
+ const char *output_target;
{
struct name_list
{
char *dir = make_tempname (bfd_get_filename (obfd));
/* Make a temp directory to hold the contents. */
+#if defined (_WIN32) && !defined (__CYGWIN32__)
+ if (mkdir (dir) != 0)
+#else
if (mkdir (dir, 0700) != 0)
+#endif
{
fatal ("cannot mkdir %s for archive copying (error: %s)",
dir, strerror (errno));
while (this_element != (bfd *) NULL)
{
/* Create an output file for this member. */
- char *output_name = cat (dir, "/", bfd_get_filename(this_element));
+ char *output_name = concat (dir, "/", bfd_get_filename(this_element),
+ (char *) NULL);
bfd *output_bfd = bfd_openw (output_name, output_target);
bfd *last_element;
static void
copy_file (input_filename, output_filename, input_target, output_target)
- char *input_filename;
- char *output_filename;
- char *input_target;
- char *output_target;
+ const char *input_filename;
+ const char *output_filename;
+ const char *input_target;
+ const char *output_target;
{
bfd *ibfd;
char **matching;
struct section_list *p;
sec_ptr osection;
bfd_vma vma;
+ bfd_vma lma;
flagword flags;
char *err;
&& (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);
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))
&& (strip_symbols == strip_debug
|| strip_symbols == strip_unneeded
|| strip_symbols == strip_all
- || discard_locals == locals_all))
+ || discard_locals == locals_all
+ || convert_debugging))
{
return;
}
}
free (memhunk);
}
+ else if (p != NULL && p->set_flags && (p->flags & SEC_HAS_CONTENTS) != 0)
+ {
+ PTR memhunk = (PTR) xmalloc ((unsigned) size);
+
+ /* We don't permit the user to turn off the SEC_HAS_CONTENTS
+ flag--they can just remove the section entirely and add it
+ back again. However, we do permit them to turn on the
+ SEC_HAS_CONTENTS flag, and take it to mean that the section
+ contents should be zeroed out. */
+
+ memset (memhunk, 0, size);
+ if (! bfd_set_section_contents (obfd, osection, memhunk, (file_ptr) 0,
+ size))
+ nonfatal (bfd_get_filename (obfd));
+ free (memhunk);
+ }
}
/* Get all the sections. This is used when --gap-fill or --pad-to is
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);
+
+ if (bfd_get_flavour (obfd) == bfd_target_coff_flavour
+ || bfd_get_flavour (obfd) == bfd_target_elf_flavour)
+ {
+ bfd_byte *syms, *strings;
+ bfd_size_type symsize, stringsize;
+ asection *stabsec, *stabstrsec;
+
+ if (! write_stabs_in_sections_debugging_info (obfd, dhandle, &syms,
+ &symsize, &strings,
+ &stringsize))
+ return false;
+
+ stabsec = bfd_make_section (obfd, ".stab");
+ stabstrsec = bfd_make_section (obfd, ".stabstr");
+ if (stabsec == NULL
+ || stabstrsec == NULL
+ || ! bfd_set_section_size (obfd, stabsec, symsize)
+ || ! bfd_set_section_size (obfd, stabstrsec, stringsize)
+ || ! bfd_set_section_alignment (obfd, stabsec, 2)
+ || ! bfd_set_section_alignment (obfd, stabstrsec, 0)
+ || ! bfd_set_section_flags (obfd, stabsec,
+ (SEC_HAS_CONTENTS
+ | SEC_READONLY
+ | SEC_DEBUGGING))
+ || ! bfd_set_section_flags (obfd, stabstrsec,
+ (SEC_HAS_CONTENTS
+ | SEC_READONLY
+ | SEC_DEBUGGING)))
+ {
+ fprintf (stderr, "%s: can't create debugging section: %s\n",
+ bfd_get_filename (obfd), bfd_errmsg (bfd_get_error ()));
+ return false;
+ }
+
+ /* We can get away with setting the section contents now because
+ the next thing the caller is going to do is copy over the
+ real sections. We may someday have to split the contents
+ setting out of this function. */
+ if (! bfd_set_section_contents (obfd, stabsec, syms, (file_ptr) 0,
+ symsize)
+ || ! bfd_set_section_contents (obfd, stabstrsec, strings,
+ (file_ptr) 0, stringsize))
+ {
+ fprintf (stderr, "%s: can't set debugging section contents: %s\n",
+ bfd_get_filename (obfd), bfd_errmsg (bfd_get_error ()));
+ return false;
+ }
+
+ return true;
+ }
+
+ 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
static int
simple_copy (from, to)
- char *from, *to;
+ const char *from;
+ const char *to;
{
int fromfd, tofd, nread;
int saved;
static int
smart_rename (from, to)
- char *from, *to;
+ const char *from;
+ const char *to;
{
struct stat s;
int ret = 0;
if (lstat (to, &s))
return -1;
+#if defined (_WIN32) && !defined (__CYGWIN32__)
+ /* Win32, unlike unix, will not erase `to' in `rename(from, to)' but
+ fail instead. Also, chown is not present. */
+
+ if (stat (to, &s) == 0)
+ remove (to);
+
+ ret = rename (from, to);
+ if (ret != 0)
+ {
+ /* We have to clean up here. */
+ int saved = errno;
+ fprintf (stderr, "%s: %s: ", program_name, to);
+ errno = saved;
+ perror ("rename");
+ unlink (from);
+ }
+#else
/* Use rename only if TO is not a symbolic link and has
only one hard link. */
if (!S_ISLNK (s.st_mode) && s.st_nlink == 1)
ret = rename (from, to);
if (ret == 0)
{
- /* Try to preserve the permission bits and ownership of TO. */
- chmod (to, s.st_mode & 07777);
- chown (to, s.st_uid, s.st_gid);
+ /* Try to preserve the permission bits and ownership of TO.
+ First get the mode right except for the setuid bit. Then
+ change the ownership. Then fix the setuid bit. We do
+ the chmod before the chown because if the chown succeeds,
+ and we are a normal user, we won't be able to do the
+ chmod afterward. We don't bother to fix the setuid bit
+ first because that might introduce a fleeting security
+ problem, and because the chown will clear the setuid bit
+ anyhow. We only fix the setuid bit if the chown
+ succeeds, because we don't want to introduce an
+ unexpected setuid file owned by the user running objcopy. */
+ chmod (to, s.st_mode & 0777);
+ if (chown (to, s.st_uid, s.st_gid) >= 0)
+ chmod (to, s.st_mode & 07777);
}
else
{
}
unlink (from);
}
+#endif /* _WIN32 && !__CYGWIN32__ */
+
return ret;
}
+/* Set the times of the file DESTINATION to be the same as those in
+ STATBUF. */
+
+static void
+set_times (destination, statbuf)
+ const char *destination;
+ const struct stat *statbuf;
+{
+ int result;
+
+ {
+#ifdef HAVE_GOOD_UTIME_H
+ struct utimbuf tb;
+
+ tb.actime = statbuf->st_atime;
+ tb.modtime = statbuf->st_mtime;
+ result = utime (destination, &tb);
+#else /* ! HAVE_GOOD_UTIME_H */
+#ifndef HAVE_UTIMES
+ long tb[2];
+
+ tb[0] = statbuf->st_atime;
+ tb[1] = statbuf->st_mtime;
+ result = utime (destination, tb);
+#else /* HAVE_UTIMES */
+ struct timeval tv[2];
+
+ tv[0].tv_sec = statbuf->st_atime;
+ tv[0].tv_usec = 0;
+ tv[1].tv_sec = statbuf->st_mtime;
+ tv[1].tv_usec = 0;
+ result = utimes (destination, tv);
+#endif /* HAVE_UTIMES */
+#endif /* ! HAVE_GOOD_UTIME_H */
+ }
+
+ if (result != 0)
+ {
+ fprintf (stderr, "%s: ", destination);
+ perror ("can not set time");
+ }
+}
+
static int
strip_main (argc, argv)
int argc;
{
char *input_target = NULL, *output_target = NULL;
boolean show_version = false;
+ boolean preserve_dates = false;
int c, i;
struct section_list *p;
+ char *output_file = NULL;
- while ((c = getopt_long (argc, argv, "I:O:F:K:N:R:sSgxXVv",
+ while ((c = getopt_long (argc, argv, "I:O:F:K:N:R:o:sSpgxXVv",
strip_options, (int *) 0)) != EOF)
{
switch (c)
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);
+ add_specific_symbol (optarg, &keep_specific_list);
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);
+ add_specific_symbol (optarg, &strip_specific_list);
+ break;
+ case 'o':
+ output_file = optarg;
+ break;
+ case 'p':
+ preserve_dates = true;
break;
case 'x':
discard_locals = locals_all;
}
if (show_version)
- {
- printf ("GNU %s version %s\n", program_name, program_version);
- exit (0);
- }
+ print_version ("strip");
/* Default is to strip all symbols. */
if (strip_symbols == strip_undef
output_target = input_target;
i = optind;
- if (i == argc)
+ if (i == argc
+ || (output_file != NULL && (i + 1) < argc))
strip_usage (stderr, 1);
for (; i < argc; i++)
{
int hold_status = status;
+ struct stat statbuf;
+ char *tmpname;
- char *tmpname = make_tempname (argv[i]);
+ if (preserve_dates)
+ {
+ if (stat (argv[i], &statbuf) < 0)
+ {
+ fprintf (stderr, "%s: ", argv[i]);
+ perror ("cannot stat");
+ continue;
+ }
+ }
+
+ if (output_file != NULL)
+ tmpname = output_file;
+ else
+ tmpname = make_tempname (argv[i]);
status = 0;
+
copy_file (argv[i], tmpname, input_target, output_target);
if (status == 0)
{
- smart_rename (tmpname, argv[i]);
+ if (preserve_dates)
+ set_times (tmpname, &statbuf);
+ if (output_file == NULL)
+ smart_rename (tmpname, argv[i]);
status = hold_status;
}
else
unlink (tmpname);
- free (tmpname);
+ if (output_file == NULL)
+ free (tmpname);
}
return 0;
char *input_target = NULL, *output_target = NULL;
boolean show_version = false;
boolean adjust_warn = true;
+ boolean preserve_dates = false;
int c;
struct section_list *p;
+ struct stat statbuf;
- while ((c = getopt_long (argc, argv, "b:i:I:K:N:s:O:d:F:R:SgxXVv",
+ while ((c = getopt_long (argc, argv, "b:i:I:K:N:s:O:d:F:L:R:SpgxXVvW:",
copy_options, (int *) 0)) != EOF)
{
switch (c)
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);
+ add_specific_symbol (optarg, &keep_specific_list);
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);
+ add_specific_symbol (optarg, &strip_specific_list);
+ break;
+ case 'L':
+ add_specific_symbol (optarg, &localize_specific_list);
+ break;
+ case 'W':
+ add_specific_symbol (optarg, &weaken_specific_list);
+ break;
+ case 'p':
+ preserve_dates = true;
break;
case 'x':
discard_locals = locals_all;
case 'V':
show_version = true;
break;
+ case OPTION_WEAKEN:
+ weaken = true;
+ break;
case OPTION_ADD_SECTION:
{
const char *s;
case OPTION_ADJUST_WARNINGS:
adjust_warn = true;
break;
+ case OPTION_CHANGE_LEADING_CHAR:
+ change_leading_char = true;
+ break;
+ case OPTION_DEBUGGING:
+ convert_debugging = true;
+ break;
case OPTION_GAP_FILL:
{
bfd_vma gap_fill_vma;
pad_to = parse_vma (optarg, "--pad-to");
pad_to_set = true;
break;
+ case OPTION_REMOVE_LEADING_CHAR:
+ remove_leading_char = true;
+ break;
case OPTION_SET_SECTION_FLAGS:
{
const char *s;
}
if (show_version)
- {
- printf ("GNU %s version %s\n", program_name, program_version);
- exit (0);
- }
+ print_version ("objcopy");
if (copy_byte >= interleave)
{
if (output_target == (char *) NULL)
output_target = input_target;
+ if (preserve_dates)
+ {
+ if (stat (input_filename, &statbuf) < 0)
+ {
+ fprintf (stderr, "%s: ", input_filename);
+ perror ("cannot stat");
+ exit (1);
+ }
+ }
+
/* If there is no destination file then create a temp and rename
the result into the input. */
if (output_filename == (char *) NULL)
{
char *tmpname = make_tempname (input_filename);
+
copy_file (input_filename, tmpname, input_target, output_target);
if (status == 0)
- smart_rename (tmpname, input_filename);
+ {
+ if (preserve_dates)
+ set_times (tmpname, &statbuf);
+ smart_rename (tmpname, input_filename);
+ }
else
unlink (tmpname);
}
else
{
copy_file (input_filename, output_filename, input_target, output_target);
+ if (status == 0 && preserve_dates)
+ set_times (output_filename, &statbuf);
}
if (adjust_warn)
discard_locals = locals_undef;
bfd_init ();
+ set_default_bfd_target ();
if (is_strip < 0)
{
projects / binutils-gdb.git / blobdiff