1 /* objcopy.c -- copy object file from input to output, optionally massaging it.
2 Copyright (C) 1991, 92, 93, 94, 95, 96, 97, 98, 1999
3 Free Software Foundation, Inc.
5 This file is part of GNU Binutils.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
26 #include "libiberty.h"
30 /* A list of symbols to explicitly strip out, or to keep. A linked
31 list is good enough for a small number from the command line, but
32 this will slow things down a lot if many symbols are being
41 static void copy_usage PARAMS ((FILE *, int));
42 static void strip_usage PARAMS ((FILE *, int));
43 static flagword parse_flags PARAMS ((const char *));
44 static struct section_list *find_section_list PARAMS ((const char *, boolean));
45 static void setup_section PARAMS ((bfd *, asection *, PTR));
46 static void copy_section PARAMS ((bfd *, asection *, PTR));
47 static void get_sections PARAMS ((bfd *, asection *, PTR));
48 static int compare_section_lma PARAMS ((const PTR, const PTR));
49 static void add_specific_symbol PARAMS ((const char *, struct symlist **));
50 static boolean is_specified_symbol PARAMS ((const char *, struct symlist *));
51 static boolean is_strip_section PARAMS ((bfd *, asection *));
52 static unsigned int filter_symbols
53 PARAMS ((bfd *, bfd *, asymbol **, asymbol **, long));
54 static void mark_symbols_used_in_relocations PARAMS ((bfd *, asection *, PTR));
55 static void filter_bytes PARAMS ((char *, bfd_size_type *));
56 static boolean write_debugging_info PARAMS ((bfd *, PTR, long *, asymbol ***));
57 static void copy_object PARAMS ((bfd *, bfd *));
58 static void copy_archive PARAMS ((bfd *, bfd *, const char *));
60 PARAMS ((const char *, const char *, const char *, const char *));
61 static int strip_main PARAMS ((int, char **));
62 static int copy_main PARAMS ((int, char **));
64 #define RETURN_NONFATAL(s) {bfd_nonfatal (s); status = 1; return;}
66 static asymbol **isympp = NULL; /* Input symbols */
67 static asymbol **osympp = NULL; /* Output symbols that survive stripping */
69 /* If `copy_byte' >= 0, copy only that byte of every `interleave' bytes. */
70 static int copy_byte = -1;
71 static int interleave = 4;
73 static boolean verbose; /* Print file and target names. */
74 static boolean preserve_dates; /* Preserve input file timestamp. */
75 static int status = 0; /* Exit status. */
80 STRIP_NONE, /* don't strip */
81 STRIP_DEBUG, /* strip all debugger symbols */
82 STRIP_UNNEEDED, /* strip unnecessary symbols */
83 STRIP_ALL /* strip all symbols */
86 /* Which symbols to remove. */
87 static enum strip_action strip_symbols;
92 LOCALS_START_L, /* discard locals starting with L */
93 LOCALS_ALL /* discard all locals */
96 /* Which local symbols to remove. Overrides STRIP_ALL. */
97 static enum locals_action discard_locals;
99 /* What kind of change to perform. */
107 /* Structure used to hold lists of sections and actions to take. */
110 struct section_list * next; /* Next section to change. */
111 const char * name; /* Section name. */
112 boolean used; /* Whether this entry was used. */
113 boolean remove; /* Whether to remove this section. */
114 boolean copy; /* Whether to copy this section. */
115 enum change_action change_vma;/* Whether to change or set VMA. */
116 bfd_vma vma_val; /* Amount to change by or set to. */
117 enum change_action change_lma;/* Whether to change or set LMA. */
118 bfd_vma lma_val; /* Amount to change by or set to. */
119 boolean set_flags; /* Whether to set the section flags. */
120 flagword flags; /* What to set the section flags to. */
123 static struct section_list *change_sections;
124 static boolean sections_removed;
125 static boolean sections_copied;
127 /* Changes to the start address. */
128 static bfd_vma change_start = 0;
129 static boolean set_start_set = false;
130 static bfd_vma set_start;
132 /* Changes to section addresses. */
133 static bfd_vma change_section_address = 0;
135 /* Filling gaps between sections. */
136 static boolean gap_fill_set = false;
137 static bfd_byte gap_fill = 0;
139 /* Pad to a given address. */
140 static boolean pad_to_set = false;
141 static bfd_vma pad_to;
143 /* List of sections to add. */
147 /* Next section to add. */
148 struct section_add *next;
149 /* Name of section to add. */
151 /* Name of file holding section contents. */
152 const char *filename;
155 /* Contents of file. */
157 /* BFD section, after it has been added. */
161 static struct section_add *add_sections;
163 /* Whether to convert debugging information. */
165 static boolean convert_debugging = false;
167 /* Whether to change the leading character in symbol names. */
169 static boolean change_leading_char = false;
171 /* Whether to remove the leading character from global symbol names. */
173 static boolean remove_leading_char = false;
175 /* List of symbols to strip, keep, localize, and weaken. */
177 static struct symlist *strip_specific_list = NULL;
178 static struct symlist *keep_specific_list = NULL;
179 static struct symlist *localize_specific_list = NULL;
180 static struct symlist *weaken_specific_list = NULL;
182 /* If this is true, we weaken global symbols (set BSF_WEAK). */
184 static boolean weaken = false;
186 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
188 #define OPTION_ADD_SECTION 150
189 #define OPTION_CHANGE_ADDRESSES (OPTION_ADD_SECTION + 1)
190 #define OPTION_CHANGE_LEADING_CHAR (OPTION_CHANGE_ADDRESSES + 1)
191 #define OPTION_CHANGE_START (OPTION_CHANGE_LEADING_CHAR + 1)
192 #define OPTION_CHANGE_SECTION_ADDRESS (OPTION_CHANGE_START + 1)
193 #define OPTION_CHANGE_SECTION_LMA (OPTION_CHANGE_SECTION_ADDRESS + 1)
194 #define OPTION_CHANGE_SECTION_VMA (OPTION_CHANGE_SECTION_LMA + 1)
195 #define OPTION_CHANGE_WARNINGS (OPTION_CHANGE_SECTION_VMA + 1)
196 #define OPTION_DEBUGGING (OPTION_CHANGE_WARNINGS + 1)
197 #define OPTION_GAP_FILL (OPTION_DEBUGGING + 1)
198 #define OPTION_NO_CHANGE_WARNINGS (OPTION_GAP_FILL + 1)
199 #define OPTION_PAD_TO (OPTION_NO_CHANGE_WARNINGS + 1)
200 #define OPTION_REMOVE_LEADING_CHAR (OPTION_PAD_TO + 1)
201 #define OPTION_SET_SECTION_FLAGS (OPTION_REMOVE_LEADING_CHAR + 1)
202 #define OPTION_SET_START (OPTION_SET_SECTION_FLAGS + 1)
203 #define OPTION_STRIP_UNNEEDED (OPTION_SET_START + 1)
204 #define OPTION_WEAKEN (OPTION_STRIP_UNNEEDED + 1)
206 /* Options to handle if running as "strip". */
208 static struct option strip_options[] =
210 {"discard-all", no_argument, 0, 'x'},
211 {"discard-locals", no_argument, 0, 'X'},
212 {"format", required_argument, 0, 'F'}, /* Obsolete */
213 {"help", no_argument, 0, 'h'},
214 {"input-format", required_argument, 0, 'I'}, /* Obsolete */
215 {"input-target", required_argument, 0, 'I'},
216 {"keep-symbol", required_argument, 0, 'K'},
217 {"output-format", required_argument, 0, 'O'}, /* Obsolete */
218 {"output-target", required_argument, 0, 'O'},
219 {"preserve-dates", no_argument, 0, 'p'},
220 {"remove-section", required_argument, 0, 'R'},
221 {"strip-all", no_argument, 0, 's'},
222 {"strip-debug", no_argument, 0, 'S'},
223 {"strip-unneeded", no_argument, 0, OPTION_STRIP_UNNEEDED},
224 {"strip-symbol", required_argument, 0, 'N'},
225 {"target", required_argument, 0, 'F'},
226 {"verbose", no_argument, 0, 'v'},
227 {"version", no_argument, 0, 'V'},
228 {0, no_argument, 0, 0}
231 /* Options to handle if running as "objcopy". */
233 static struct option copy_options[] =
235 {"add-section", required_argument, 0, OPTION_ADD_SECTION},
236 {"adjust-start", required_argument, 0, OPTION_CHANGE_START},
237 {"adjust-vma", required_argument, 0, OPTION_CHANGE_ADDRESSES},
238 {"adjust-section-vma", required_argument, 0, OPTION_CHANGE_SECTION_ADDRESS},
239 {"adjust-warnings", no_argument, 0, OPTION_CHANGE_WARNINGS},
240 {"byte", required_argument, 0, 'b'},
241 {"change-addresses", required_argument, 0, OPTION_CHANGE_ADDRESSES},
242 {"change-leading-char", no_argument, 0, OPTION_CHANGE_LEADING_CHAR},
243 {"change-section-address", required_argument, 0, OPTION_CHANGE_SECTION_ADDRESS},
244 {"change-section-lma", required_argument, 0, OPTION_CHANGE_SECTION_LMA},
245 {"change-section-vma", required_argument, 0, OPTION_CHANGE_SECTION_VMA},
246 {"change-start", required_argument, 0, OPTION_CHANGE_START},
247 {"change-warnings", no_argument, 0, OPTION_CHANGE_WARNINGS},
248 {"debugging", no_argument, 0, OPTION_DEBUGGING},
249 {"discard-all", no_argument, 0, 'x'},
250 {"discard-locals", no_argument, 0, 'X'},
251 {"only-section", required_argument, 0, 'j'},
252 {"format", required_argument, 0, 'F'}, /* Obsolete */
253 {"gap-fill", required_argument, 0, OPTION_GAP_FILL},
254 {"help", no_argument, 0, 'h'},
255 {"input-format", required_argument, 0, 'I'}, /* Obsolete */
256 {"input-target", required_argument, 0, 'I'},
257 {"interleave", required_argument, 0, 'i'},
258 {"keep-symbol", required_argument, 0, 'K'},
259 {"no-adjust-warnings", no_argument, 0, OPTION_NO_CHANGE_WARNINGS},
260 {"no-change-warnings", no_argument, 0, OPTION_NO_CHANGE_WARNINGS},
261 {"output-format", required_argument, 0, 'O'}, /* Obsolete */
262 {"output-target", required_argument, 0, 'O'},
263 {"pad-to", required_argument, 0, OPTION_PAD_TO},
264 {"preserve-dates", no_argument, 0, 'p'},
265 {"localize-symbol", required_argument, 0, 'L'},
266 {"remove-leading-char", no_argument, 0, OPTION_REMOVE_LEADING_CHAR},
267 {"remove-section", required_argument, 0, 'R'},
268 {"set-section-flags", required_argument, 0, OPTION_SET_SECTION_FLAGS},
269 {"set-start", required_argument, 0, OPTION_SET_START},
270 {"strip-all", no_argument, 0, 'S'},
271 {"strip-debug", no_argument, 0, 'g'},
272 {"strip-unneeded", no_argument, 0, OPTION_STRIP_UNNEEDED},
273 {"strip-symbol", required_argument, 0, 'N'},
274 {"target", required_argument, 0, 'F'},
275 {"verbose", no_argument, 0, 'v'},
276 {"version", no_argument, 0, 'V'},
277 {"weaken", no_argument, 0, OPTION_WEAKEN},
278 {"weaken-symbol", required_argument, 0, 'W'},
279 {0, no_argument, 0, 0}
283 extern char *program_name;
285 /* This flag distinguishes between strip and objcopy:
286 1 means this is 'strip'; 0 means this is 'objcopy'.
287 -1 means if we should use argv[0] to decide. */
292 copy_usage (stream, exit_status)
296 fprintf (stream, _("Usage: %s <switches> in-file [out-file]\n"), program_name);
297 fprintf (stream, _(" The switches are:\n"));
298 fprintf (stream, _("\
299 -I --input-target <bfdname> Assume input file is in format <bfdname>\n\
300 -O --output-target <bfdname> Create an output file in format <bfdname>\n\
301 -F --target <bfdname> Set both input and output format to <bfdname>\n\
302 --debugging Convert debugging information, if possible\n\
303 -p --preserve-dates Copy modified/access timestamps to the output\n\
304 -j --only-section <name> Only copy section <name> into the output\n\
305 -R --remove-section <name> Remove section <name> from the output\n\
306 -S --strip-all Remove all symbol and relocation information\n\
307 -g --strip-debug Remove all debugging symbols\n\
308 --strip-unneeded Remove all symbols not needed by relocations\n\
309 -N --strip-symbol <name> Do not copy symbol <name>\n\
310 -K --keep-symbol <name> Only copy symbol <name>\n\
311 -L --localize-symbol <name> Force symbol <name> to be marked as a local\n\
312 -W --weaken-symbol <name> Force symbol <name> to be marked as a weak\n\
313 --weaken Force all global symbols to be marked as weak\n\
314 -x --discard-all Remove all non-global symbols\n\
315 -X --discard-locals Remove any compiler-generated symbols\n\
316 -i --interleave <number> Only copy one out of every <number> bytes\n\
317 -b --byte <num> Select byte <num> in every interleaved block\n\
318 --gap-fill <val> Fill gaps between sections with <val>\n\
319 --pad-to <addr> Pad the last section up to address <addr>\n\
320 --set-start <addr> Set the start address to <addr>\n\
321 {--change-start|--adjust-start} <incr>\n\
322 Add <incr> to the start address\n\
323 {--change-addresses|--adjust-vma} <incr>\n\
324 Add <incr> to LMA, VMA and start addresses\n\
325 {--change-section-address|--adjust-section-vma} <name>{=|+|-}<val>\n\
326 Change LMA and VMA of section <name> by <val>\n\
327 --change-section-lma <name>{=|+|-}<val>\n\
328 Change the LMA of section <name> by <val>\n\
329 --change-section-vma <name>{=|+|-}<val>\n\
330 Change the VMA of section <name> by <val>\n\
331 {--[no-]change-warnings|--[no-]adjust-warnings}\n\
332 Warn if a named section does not exist\n\
333 --set-section-flags <name>=<flags>\n\
334 Set section <name>'s properties to <flags>\n\
335 --add-section <name>=<file> Add section <name> found in <file> to output\n\
336 --change-leading-char Force output format's leading character style\n\
337 --remove-leading-char Remove leading character from global symbols\n\
338 -v --verbose List all object files modified\n\
339 -V --version Display this program's version number\n\
340 -h --help Display this output\n\
342 list_supported_targets (program_name, stream);
343 if (exit_status == 0)
344 fprintf (stream, _("Report bugs to %s\n"), REPORT_BUGS_TO);
349 strip_usage (stream, exit_status)
353 fprintf (stream, _("Usage: %s <switches> in-file(s)\n"), program_name);
354 fprintf (stream, _(" The switches are:\n"));
355 fprintf (stream, _("\
356 -I --input-target <bfdname> Assume input file is in format <bfdname>\n\
357 -O --output-target <bfdname> Create an output file in format <bfdname>\n\
358 -F --target <bfdname> Set both input and output format to <bfdname>\n\
359 -p --preserve-dates Copy modified/access timestamps to the output\n\
360 -R --remove-section <name> Remove section <name> from the output\n\
361 -s --strip-all Remove all symbol and relocation information\n\
362 -g -S --strip-debug Remove all debugging symbols\n\
363 --strip-unneeded Remove all symbols not needed by relocations\n\
364 -N --strip-symbol <name> Do not copy symbol <name>\n\
365 -K --keep-symbol <name> Only copy symbol <name>\n\
366 -x --discard-all Remove all non-global symbols\n\
367 -X --discard-locals Remove any compiler-generated symbols\n\
368 -v --verbose List all object files modified\n\
369 -V --version Display this program's version number\n\
370 -h --help Display this output\n\
371 -o <file> Place stripped output into <file>\n\
374 list_supported_targets (program_name, stream);
375 if (exit_status == 0)
376 fprintf (stream, _("Report bugs to %s\n"), REPORT_BUGS_TO);
380 /* Parse section flags into a flagword, with a fatal error if the
381 string can't be parsed. */
395 snext = strchr (s, ',');
405 #define PARSE_FLAG(fname,fval) \
406 else if (strncasecmp (fname, s, len) == 0) ret |= fval
407 PARSE_FLAG ("alloc", SEC_ALLOC);
408 PARSE_FLAG ("load", SEC_LOAD);
409 PARSE_FLAG ("noload", SEC_NEVER_LOAD);
410 PARSE_FLAG ("readonly", SEC_READONLY);
411 PARSE_FLAG ("debug", SEC_DEBUGGING);
412 PARSE_FLAG ("code", SEC_CODE);
413 PARSE_FLAG ("data", SEC_DATA);
414 PARSE_FLAG ("rom", SEC_ROM);
415 PARSE_FLAG ("share", SEC_SHARED);
416 PARSE_FLAG ("contents", SEC_HAS_CONTENTS);
422 copy = xmalloc (len + 1);
423 strncpy (copy, s, len);
425 non_fatal (_("unrecognized section flag `%s'"), copy);
426 fatal (_("supported flags: alloc, load, noload, readonly, debug, code, data, rom, share, contents"));
436 /* Find and optionally add an entry in the change_sections list. */
438 static struct section_list *
439 find_section_list (name, add)
443 register struct section_list *p;
445 for (p = change_sections; p != NULL; p = p->next)
446 if (strcmp (p->name, name) == 0)
452 p = (struct section_list *) xmalloc (sizeof (struct section_list));
457 p->change_vma = CHANGE_IGNORE;
458 p->change_lma = CHANGE_IGNORE;
461 p->set_flags = false;
464 p->next = change_sections;
470 /* Add a symbol to strip_specific_list. */
473 add_specific_symbol (name, list)
475 struct symlist **list;
477 struct symlist *tmp_list;
479 tmp_list = (struct symlist *) xmalloc (sizeof (struct symlist));
480 tmp_list->name = name;
481 tmp_list->next = *list;
485 /* See whether a symbol should be stripped or kept based on
486 strip_specific_list and keep_symbols. */
489 is_specified_symbol (name, list)
491 struct symlist *list;
493 struct symlist *tmp_list;
495 for (tmp_list = list; tmp_list; tmp_list = tmp_list->next)
497 if (strcmp (name, tmp_list->name) == 0)
503 /* See if a section is being removed. */
506 is_strip_section (abfd, sec)
507 bfd *abfd ATTRIBUTE_UNUSED;
510 struct section_list *p;
512 if ((bfd_get_section_flags (abfd, sec) & SEC_DEBUGGING) != 0
513 && (strip_symbols == STRIP_DEBUG
514 || strip_symbols == STRIP_UNNEEDED
515 || strip_symbols == STRIP_ALL
516 || discard_locals == LOCALS_ALL
517 || convert_debugging))
520 if (! sections_removed && ! sections_copied)
523 p = find_section_list (bfd_get_section_name (abfd, sec), false);
524 if (sections_removed && p != NULL && p->remove)
526 if (sections_copied && (p == NULL || ! p->copy))
531 /* Choose which symbol entries to copy; put the result in OSYMS.
532 We don't copy in place, because that confuses the relocs.
533 Return the number of symbols to print. */
536 filter_symbols (abfd, obfd, osyms, isyms, symcount)
539 asymbol **osyms, **isyms;
542 register asymbol **from = isyms, **to = osyms;
543 long src_count = 0, dst_count = 0;
545 for (; src_count < symcount; src_count++)
547 asymbol *sym = from[src_count];
548 flagword flags = sym->flags;
549 const char *name = bfd_asymbol_name (sym);
552 if (change_leading_char
553 && (bfd_get_symbol_leading_char (abfd)
554 != bfd_get_symbol_leading_char (obfd))
555 && (bfd_get_symbol_leading_char (abfd) == '\0'
556 || (name[0] == bfd_get_symbol_leading_char (abfd))))
558 if (bfd_get_symbol_leading_char (obfd) == '\0')
559 name = bfd_asymbol_name (sym) = name + 1;
564 n = xmalloc (strlen (name) + 2);
565 n[0] = bfd_get_symbol_leading_char (obfd);
566 if (bfd_get_symbol_leading_char (abfd) == '\0')
567 strcpy (n + 1, name);
569 strcpy (n + 1, name + 1);
570 name = bfd_asymbol_name (sym) = n;
574 if (remove_leading_char
575 && ((flags & BSF_GLOBAL) != 0
576 || (flags & BSF_WEAK) != 0
577 || bfd_is_und_section (bfd_get_section (sym))
578 || bfd_is_com_section (bfd_get_section (sym)))
579 && name[0] == bfd_get_symbol_leading_char (abfd))
580 name = bfd_asymbol_name (sym) = name + 1;
582 if (strip_symbols == STRIP_ALL)
584 else if ((flags & BSF_KEEP) != 0 /* Used in relocation. */
585 || ((flags & BSF_SECTION_SYM) != 0
586 && ((*bfd_get_section (sym)->symbol_ptr_ptr)->flags
589 else if ((flags & BSF_GLOBAL) != 0 /* Global symbol. */
590 || (flags & BSF_WEAK) != 0
591 || bfd_is_und_section (bfd_get_section (sym))
592 || bfd_is_com_section (bfd_get_section (sym)))
593 keep = strip_symbols != STRIP_UNNEEDED;
594 else if ((flags & BSF_DEBUGGING) != 0) /* Debugging symbol. */
595 keep = (strip_symbols != STRIP_DEBUG
596 && strip_symbols != STRIP_UNNEEDED
597 && ! convert_debugging);
598 else /* Local symbol. */
599 keep = (strip_symbols != STRIP_UNNEEDED
600 && (discard_locals != LOCALS_ALL
601 && (discard_locals != LOCALS_START_L
602 || ! bfd_is_local_label (abfd, sym))));
604 if (keep && is_specified_symbol (name, strip_specific_list))
606 if (!keep && is_specified_symbol (name, keep_specific_list))
608 if (keep && is_strip_section (abfd, bfd_get_section (sym)))
611 if (keep && (flags & BSF_GLOBAL) != 0
612 && (weaken || is_specified_symbol (name, weaken_specific_list)))
614 sym->flags &=~ BSF_GLOBAL;
615 sym->flags |= BSF_WEAK;
617 if (keep && (flags & (BSF_GLOBAL | BSF_WEAK))
618 && is_specified_symbol (name, localize_specific_list))
620 sym->flags &= ~(BSF_GLOBAL | BSF_WEAK);
621 sym->flags |= BSF_LOCAL;
625 to[dst_count++] = sym;
628 to[dst_count] = NULL;
633 /* Keep only every `copy_byte'th byte in MEMHUNK, which is *SIZE bytes long.
637 filter_bytes (memhunk, size)
641 char *from = memhunk + copy_byte, *to = memhunk, *end = memhunk + *size;
643 for (; from < end; from += interleave)
645 if (*size % interleave > (bfd_size_type) copy_byte)
646 *size = (*size / interleave) + 1;
651 /* Copy object file IBFD onto OBFD. */
654 copy_object (ibfd, obfd)
660 asection **osections = NULL;
661 bfd_size_type *gaps = NULL;
662 bfd_size_type max_gap = 0;
667 if (!bfd_set_format (obfd, bfd_get_format (ibfd)))
668 RETURN_NONFATAL (bfd_get_filename (obfd));
671 printf (_("copy from %s(%s) to %s(%s)\n"),
672 bfd_get_filename (ibfd), bfd_get_target (ibfd),
673 bfd_get_filename (obfd), bfd_get_target (obfd));
678 start = bfd_get_start_address (ibfd);
679 start += change_start;
681 if (!bfd_set_start_address (obfd, start)
682 || !bfd_set_file_flags (obfd,
683 (bfd_get_file_flags (ibfd)
684 & bfd_applicable_file_flags (obfd))))
685 RETURN_NONFATAL (bfd_get_filename (ibfd));
687 /* Copy architecture of input file to output file */
688 if (!bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
689 bfd_get_mach (ibfd)))
690 non_fatal (_("Warning: Output file cannot represent architecture %s"),
691 bfd_printable_arch_mach (bfd_get_arch (ibfd),
692 bfd_get_mach (ibfd)));
694 if (!bfd_set_format (obfd, bfd_get_format (ibfd)))
695 RETURN_NONFATAL (bfd_get_filename (ibfd));
700 if (osympp != isympp)
703 /* BFD mandates that all output sections be created and sizes set before
704 any output is done. Thus, we traverse all sections multiple times. */
705 bfd_map_over_sections (ibfd, setup_section, (void *) obfd);
707 if (add_sections != NULL)
709 struct section_add *padd;
710 struct section_list *pset;
712 for (padd = add_sections; padd != NULL; padd = padd->next)
714 padd->section = bfd_make_section (obfd, padd->name);
715 if (padd->section == NULL)
717 non_fatal (_("can't create section `%s': %s"),
718 padd->name, bfd_errmsg (bfd_get_error ()));
726 if (! bfd_set_section_size (obfd, padd->section, padd->size))
727 RETURN_NONFATAL (bfd_get_filename (obfd));
729 pset = find_section_list (padd->name, false);
733 if (pset != NULL && pset->set_flags)
734 flags = pset->flags | SEC_HAS_CONTENTS;
736 flags = SEC_HAS_CONTENTS | SEC_READONLY | SEC_DATA;
738 if (! bfd_set_section_flags (obfd, padd->section, flags))
739 RETURN_NONFATAL (bfd_get_filename (obfd));
743 if (pset->change_vma != CHANGE_IGNORE)
744 if (! bfd_set_section_vma (obfd, padd->section, pset->vma_val))
745 RETURN_NONFATAL (bfd_get_filename (obfd));
747 if (pset->change_lma != CHANGE_IGNORE)
749 padd->section->lma = pset->lma_val;
751 if (! bfd_set_section_alignment
752 (obfd, padd->section,
753 bfd_section_alignment (obfd, padd->section)))
754 RETURN_NONFATAL (bfd_get_filename (obfd));
761 if (gap_fill_set || pad_to_set)
766 /* We must fill in gaps between the sections and/or we must pad
767 the last section to a specified address. We do this by
768 grabbing a list of the sections, sorting them by VMA, and
769 increasing the section sizes as required to fill the gaps.
770 We write out the gap contents below. */
772 c = bfd_count_sections (obfd);
773 osections = (asection **) xmalloc (c * sizeof (asection *));
775 bfd_map_over_sections (obfd, get_sections, (void *) &set);
777 qsort (osections, c, sizeof (asection *), compare_section_lma);
779 gaps = (bfd_size_type *) xmalloc (c * sizeof (bfd_size_type));
780 memset (gaps, 0, c * sizeof (bfd_size_type));
784 for (i = 0; i < c - 1; i++)
788 bfd_vma gap_start, gap_stop;
790 flags = bfd_get_section_flags (obfd, osections[i]);
791 if ((flags & SEC_HAS_CONTENTS) == 0
792 || (flags & SEC_LOAD) == 0)
795 size = bfd_section_size (obfd, osections[i]);
796 gap_start = bfd_section_lma (obfd, osections[i]) + size;
797 gap_stop = bfd_section_lma (obfd, osections[i + 1]);
798 if (gap_start < gap_stop)
800 if (! bfd_set_section_size (obfd, osections[i],
801 size + (gap_stop - gap_start)))
803 non_fatal (_("Can't fill gap after %s: %s"),
804 bfd_get_section_name (obfd, osections[i]),
805 bfd_errmsg (bfd_get_error ()));
809 gaps[i] = gap_stop - gap_start;
810 if (max_gap < gap_stop - gap_start)
811 max_gap = gap_stop - gap_start;
821 lma = bfd_section_lma (obfd, osections[c - 1]);
822 size = bfd_section_size (obfd, osections[c - 1]);
823 if (lma + size < pad_to)
825 if (! bfd_set_section_size (obfd, osections[c - 1],
828 non_fatal (_("Can't add padding to %s: %s"),
829 bfd_get_section_name (obfd, osections[c - 1]),
830 bfd_errmsg (bfd_get_error ()));
835 gaps[c - 1] = pad_to - (lma + size);
836 if (max_gap < pad_to - (lma + size))
837 max_gap = pad_to - (lma + size);
843 /* Symbol filtering must happen after the output sections have
844 been created, but before their contents are set. */
846 symsize = bfd_get_symtab_upper_bound (ibfd);
848 RETURN_NONFATAL (bfd_get_filename (ibfd));
850 osympp = isympp = (asymbol **) xmalloc (symsize);
851 symcount = bfd_canonicalize_symtab (ibfd, isympp);
853 RETURN_NONFATAL (bfd_get_filename (ibfd));
855 if (convert_debugging)
856 dhandle = read_debugging_info (ibfd, isympp, symcount);
858 if (strip_symbols == STRIP_DEBUG
859 || strip_symbols == STRIP_ALL
860 || strip_symbols == STRIP_UNNEEDED
861 || discard_locals != LOCALS_UNDEF
862 || strip_specific_list != NULL
863 || keep_specific_list != NULL
864 || localize_specific_list != NULL
865 || weaken_specific_list != NULL
869 || change_leading_char
870 || remove_leading_char
873 /* Mark symbols used in output relocations so that they
874 are kept, even if they are local labels or static symbols.
876 Note we iterate over the input sections examining their
877 relocations since the relocations for the output sections
878 haven't been set yet. mark_symbols_used_in_relocations will
879 ignore input sections which have no corresponding output
881 if (strip_symbols != STRIP_ALL)
882 bfd_map_over_sections (ibfd,
883 mark_symbols_used_in_relocations,
885 osympp = (asymbol **) xmalloc ((symcount + 1) * sizeof (asymbol *));
886 symcount = filter_symbols (ibfd, obfd, osympp, isympp, symcount);
889 if (convert_debugging && dhandle != NULL)
891 if (! write_debugging_info (obfd, dhandle, &symcount, &osympp))
898 bfd_set_symtab (obfd, osympp, symcount);
900 /* This has to happen after the symbol table has been set. */
901 bfd_map_over_sections (ibfd, copy_section, (void *) obfd);
903 if (add_sections != NULL)
905 struct section_add *padd;
907 for (padd = add_sections; padd != NULL; padd = padd->next)
909 if (! bfd_set_section_contents (obfd, padd->section,
910 (PTR) padd->contents,
912 (bfd_size_type) padd->size))
913 RETURN_NONFATAL (bfd_get_filename (obfd));
917 if (gap_fill_set || pad_to_set)
922 /* Fill in the gaps. */
926 buf = (bfd_byte *) xmalloc (max_gap);
927 memset (buf, gap_fill, (size_t) max_gap);
929 c = bfd_count_sections (obfd);
930 for (i = 0; i < c; i++)
938 off = bfd_section_size (obfd, osections[i]) - left;
948 if (! bfd_set_section_contents (obfd, osections[i], buf,
950 RETURN_NONFATAL (bfd_get_filename (obfd));
959 /* Allow the BFD backend to copy any private data it understands
960 from the input BFD to the output BFD. This is done last to
961 permit the routine to look at the filtered symbol table, which is
962 important for the ECOFF code at least. */
963 if (!bfd_copy_private_bfd_data (ibfd, obfd))
965 non_fatal (_("%s: error copying private BFD data: %s"),
966 bfd_get_filename (obfd),
967 bfd_errmsg (bfd_get_error ()));
973 /* Read each archive element in turn from IBFD, copy the
974 contents to temp file, and keep the temp file handle. */
977 copy_archive (ibfd, obfd, output_target)
980 const char *output_target;
984 struct name_list *next;
988 bfd **ptr = &obfd->archive_head;
990 char *dir = make_tempname (bfd_get_filename (obfd));
992 /* Make a temp directory to hold the contents. */
993 #if defined (_WIN32) && !defined (__CYGWIN32__)
994 if (mkdir (dir) != 0)
996 if (mkdir (dir, 0700) != 0)
999 fatal (_("cannot mkdir %s for archive copying (error: %s)"),
1000 dir, strerror (errno));
1002 obfd->has_armap = ibfd->has_armap;
1006 this_element = bfd_openr_next_archived_file (ibfd, NULL);
1007 while (!status && this_element != (bfd *) NULL)
1009 /* Create an output file for this member. */
1010 char *output_name = concat (dir, "/", bfd_get_filename (this_element),
1012 bfd *output_bfd = bfd_openw (output_name, output_target);
1015 int stat_status = 0;
1019 stat_status = bfd_stat_arch_elt (this_element, &buf);
1020 if (stat_status != 0)
1021 non_fatal (_("internal stat error on %s"),
1022 bfd_get_filename (this_element));
1025 l = (struct name_list *) xmalloc (sizeof (struct name_list));
1026 l->name = output_name;
1030 if (output_bfd == (bfd *) NULL)
1031 RETURN_NONFATAL (output_name);
1033 if (!bfd_set_format (obfd, bfd_get_format (ibfd)))
1034 RETURN_NONFATAL (bfd_get_filename (obfd));
1036 if (bfd_check_format (this_element, bfd_object) == true)
1037 copy_object (this_element, output_bfd);
1039 if (!bfd_close (output_bfd))
1041 bfd_nonfatal (bfd_get_filename (output_bfd));
1042 /* Error in new object file. Don't change archive. */
1046 if (preserve_dates && stat_status == 0)
1047 set_times (output_name, &buf);
1049 /* Open the newly output file and attach to our list. */
1050 output_bfd = bfd_openr (output_name, output_target);
1052 l->obfd = output_bfd;
1055 ptr = &output_bfd->next;
1057 last_element = this_element;
1059 this_element = bfd_openr_next_archived_file (ibfd, last_element);
1061 bfd_close (last_element);
1063 *ptr = (bfd *) NULL;
1065 if (!bfd_close (obfd))
1066 RETURN_NONFATAL (bfd_get_filename (obfd));
1068 if (!bfd_close (ibfd))
1069 RETURN_NONFATAL (bfd_get_filename (ibfd));
1071 /* Delete all the files that we opened. */
1072 for (l = list; l != NULL; l = l->next)
1074 bfd_close (l->obfd);
1080 /* The top-level control. */
1083 copy_file (input_filename, output_filename, input_target, output_target)
1084 const char *input_filename;
1085 const char *output_filename;
1086 const char *input_target;
1087 const char *output_target;
1092 /* To allow us to do "strip *" without dying on the first
1093 non-object file, failures are nonfatal. */
1095 ibfd = bfd_openr (input_filename, input_target);
1097 RETURN_NONFATAL (input_filename);
1099 if (bfd_check_format (ibfd, bfd_archive))
1103 /* bfd_get_target does not return the correct value until
1104 bfd_check_format succeeds. */
1105 if (output_target == NULL)
1106 output_target = bfd_get_target (ibfd);
1108 obfd = bfd_openw (output_filename, output_target);
1110 RETURN_NONFATAL (output_filename);
1112 copy_archive (ibfd, obfd, output_target);
1114 else if (bfd_check_format_matches (ibfd, bfd_object, &matching))
1118 /* bfd_get_target does not return the correct value until
1119 bfd_check_format succeeds. */
1120 if (output_target == NULL)
1121 output_target = bfd_get_target (ibfd);
1123 obfd = bfd_openw (output_filename, output_target);
1125 RETURN_NONFATAL (output_filename);
1127 copy_object (ibfd, obfd);
1129 if (!bfd_close (obfd))
1130 RETURN_NONFATAL (output_filename);
1132 if (!bfd_close (ibfd))
1133 RETURN_NONFATAL (input_filename);
1137 bfd_nonfatal (input_filename);
1139 if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
1141 list_matching_formats (matching);
1149 /* Create a section in OBFD with the same name and attributes
1150 as ISECTION in IBFD. */
1153 setup_section (ibfd, isection, obfdarg)
1158 bfd *obfd = (bfd *) obfdarg;
1159 struct section_list *p;
1167 if ((bfd_get_section_flags (ibfd, isection) & SEC_DEBUGGING) != 0
1168 && (strip_symbols == STRIP_DEBUG
1169 || strip_symbols == STRIP_UNNEEDED
1170 || strip_symbols == STRIP_ALL
1171 || discard_locals == LOCALS_ALL
1172 || convert_debugging))
1175 p = find_section_list (bfd_section_name (ibfd, isection), false);
1179 if (sections_removed && p != NULL && p->remove)
1181 if (sections_copied && (p == NULL || ! p->copy))
1184 osection = bfd_make_section_anyway (obfd, bfd_section_name (ibfd, isection));
1186 if (osection == NULL)
1192 size = bfd_section_size (ibfd, isection);
1194 size = (size + interleave - 1) / interleave;
1195 if (! bfd_set_section_size (obfd, osection, size))
1201 vma = bfd_section_vma (ibfd, isection);
1202 if (p != NULL && p->change_vma == CHANGE_MODIFY)
1204 else if (p != NULL && p->change_vma == CHANGE_SET)
1207 vma += change_section_address;
1209 if (! bfd_set_section_vma (obfd, osection, vma))
1215 lma = isection->lma;
1216 if ((p != NULL) && p->change_lma != CHANGE_IGNORE)
1218 if (p->change_lma == CHANGE_MODIFY)
1220 else if (p->change_lma == CHANGE_SET)
1226 lma += change_section_address;
1228 osection->lma = lma;
1230 /* FIXME: This is probably not enough. If we change the LMA we
1231 may have to recompute the header for the file as well. */
1232 if (bfd_set_section_alignment (obfd,
1234 bfd_section_alignment (ibfd, isection))
1241 flags = bfd_get_section_flags (ibfd, isection);
1242 if (p != NULL && p->set_flags)
1243 flags = p->flags | (flags & SEC_HAS_CONTENTS);
1244 if (!bfd_set_section_flags (obfd, osection, flags))
1250 /* This used to be mangle_section; we do here to avoid using
1251 bfd_get_section_by_name since some formats allow multiple
1252 sections with the same name. */
1253 isection->output_section = osection;
1254 isection->output_offset = 0;
1256 /* Allow the BFD backend to copy any private data it understands
1257 from the input section to the output section. */
1258 if (!bfd_copy_private_section_data (ibfd, isection, obfd, osection))
1260 err = "private data";
1268 non_fatal (_("%s: section `%s': error in %s: %s"),
1269 bfd_get_filename (ibfd),
1270 bfd_section_name (ibfd, isection),
1271 err, bfd_errmsg (bfd_get_error ()));
1275 /* Copy the data of input section ISECTION of IBFD
1276 to an output section with the same name in OBFD.
1277 If stripping then don't copy any relocation info. */
1280 copy_section (ibfd, isection, obfdarg)
1285 bfd *obfd = (bfd *) obfdarg;
1286 struct section_list *p;
1293 /* If we have already failed earlier on, do not keep on generating
1298 if ((bfd_get_section_flags (ibfd, isection) & SEC_DEBUGGING) != 0
1299 && (strip_symbols == STRIP_DEBUG
1300 || strip_symbols == STRIP_UNNEEDED
1301 || strip_symbols == STRIP_ALL
1302 || discard_locals == LOCALS_ALL
1303 || convert_debugging))
1308 p = find_section_list (bfd_section_name (ibfd, isection), false);
1310 if (sections_removed && p != NULL && p->remove)
1312 if (sections_copied && (p == NULL || ! p->copy))
1315 osection = isection->output_section;
1316 size = bfd_get_section_size_before_reloc (isection);
1318 if (size == 0 || osection == 0)
1322 relsize = bfd_get_reloc_upper_bound (ibfd, isection);
1324 RETURN_NONFATAL (bfd_get_filename (ibfd));
1327 bfd_set_reloc (obfd, osection, (arelent **) NULL, 0);
1330 relpp = (arelent **) xmalloc (relsize);
1331 relcount = bfd_canonicalize_reloc (ibfd, isection, relpp, isympp);
1333 RETURN_NONFATAL (bfd_get_filename (ibfd));
1335 if (strip_symbols == STRIP_ALL)
1337 /* Remove relocations which are not in
1338 keep_strip_specific_list. */
1339 arelent **temp_relpp;
1340 long temp_relcount = 0;
1343 temp_relpp = (arelent **) xmalloc (relsize);
1344 for (i = 0; i < relcount; i++)
1345 if (is_specified_symbol
1346 (bfd_asymbol_name (*relpp [i]->sym_ptr_ptr),
1347 keep_specific_list))
1348 temp_relpp [temp_relcount++] = relpp [i];
1349 relcount = temp_relcount;
1353 bfd_set_reloc (obfd, osection,
1354 (relcount == 0 ? (arelent **) NULL : relpp), relcount);
1357 isection->_cooked_size = isection->_raw_size;
1358 isection->reloc_done = true;
1360 if (bfd_get_section_flags (ibfd, isection) & SEC_HAS_CONTENTS)
1362 PTR memhunk = (PTR) xmalloc ((unsigned) size);
1364 if (!bfd_get_section_contents (ibfd, isection, memhunk, (file_ptr) 0,
1366 RETURN_NONFATAL (bfd_get_filename (ibfd));
1369 filter_bytes (memhunk, &size);
1371 if (!bfd_set_section_contents (obfd, osection, memhunk, (file_ptr) 0,
1373 RETURN_NONFATAL (bfd_get_filename (obfd));
1377 else if (p != NULL && p->set_flags && (p->flags & SEC_HAS_CONTENTS) != 0)
1379 PTR memhunk = (PTR) xmalloc ((unsigned) size);
1381 /* We don't permit the user to turn off the SEC_HAS_CONTENTS
1382 flag--they can just remove the section entirely and add it
1383 back again. However, we do permit them to turn on the
1384 SEC_HAS_CONTENTS flag, and take it to mean that the section
1385 contents should be zeroed out. */
1387 memset (memhunk, 0, size);
1388 if (! bfd_set_section_contents (obfd, osection, memhunk, (file_ptr) 0,
1390 RETURN_NONFATAL (bfd_get_filename (obfd));
1395 /* Get all the sections. This is used when --gap-fill or --pad-to is
1399 get_sections (obfd, osection, secppparg)
1400 bfd *obfd ATTRIBUTE_UNUSED;
1404 asection ***secppp = (asection ***) secppparg;
1406 **secppp = osection;
1410 /* Sort sections by VMA. This is called via qsort, and is used when
1411 --gap-fill or --pad-to is used. We force non loadable or empty
1412 sections to the front, where they are easier to ignore. */
1415 compare_section_lma (arg1, arg2)
1419 const asection **sec1 = (const asection **) arg1;
1420 const asection **sec2 = (const asection **) arg2;
1421 flagword flags1, flags2;
1423 /* Sort non loadable sections to the front. */
1424 flags1 = (*sec1)->flags;
1425 flags2 = (*sec2)->flags;
1426 if ((flags1 & SEC_HAS_CONTENTS) == 0
1427 || (flags1 & SEC_LOAD) == 0)
1429 if ((flags2 & SEC_HAS_CONTENTS) != 0
1430 && (flags2 & SEC_LOAD) != 0)
1435 if ((flags2 & SEC_HAS_CONTENTS) == 0
1436 || (flags2 & SEC_LOAD) == 0)
1440 /* Sort sections by LMA. */
1441 if ((*sec1)->lma > (*sec2)->lma)
1443 else if ((*sec1)->lma < (*sec2)->lma)
1446 /* Sort sections with the same LMA by size. */
1447 if ((*sec1)->_raw_size > (*sec2)->_raw_size)
1449 else if ((*sec1)->_raw_size < (*sec2)->_raw_size)
1455 /* Mark all the symbols which will be used in output relocations with
1456 the BSF_KEEP flag so that those symbols will not be stripped.
1458 Ignore relocations which will not appear in the output file. */
1461 mark_symbols_used_in_relocations (ibfd, isection, symbolsarg)
1466 asymbol **symbols = (asymbol **) symbolsarg;
1471 /* Ignore an input section with no corresponding output section. */
1472 if (isection->output_section == NULL)
1475 relsize = bfd_get_reloc_upper_bound (ibfd, isection);
1477 bfd_fatal (bfd_get_filename (ibfd));
1482 relpp = (arelent **) xmalloc (relsize);
1483 relcount = bfd_canonicalize_reloc (ibfd, isection, relpp, symbols);
1485 bfd_fatal (bfd_get_filename (ibfd));
1487 /* Examine each symbol used in a relocation. If it's not one of the
1488 special bfd section symbols, then mark it with BSF_KEEP. */
1489 for (i = 0; i < relcount; i++)
1491 if (*relpp[i]->sym_ptr_ptr != bfd_com_section_ptr->symbol
1492 && *relpp[i]->sym_ptr_ptr != bfd_abs_section_ptr->symbol
1493 && *relpp[i]->sym_ptr_ptr != bfd_und_section_ptr->symbol)
1494 (*relpp[i]->sym_ptr_ptr)->flags |= BSF_KEEP;
1501 /* Write out debugging information. */
1504 write_debugging_info (obfd, dhandle, symcountp, symppp)
1507 long *symcountp ATTRIBUTE_UNUSED;
1508 asymbol ***symppp ATTRIBUTE_UNUSED;
1510 if (bfd_get_flavour (obfd) == bfd_target_ieee_flavour)
1511 return write_ieee_debugging_info (obfd, dhandle);
1513 if (bfd_get_flavour (obfd) == bfd_target_coff_flavour
1514 || bfd_get_flavour (obfd) == bfd_target_elf_flavour)
1516 bfd_byte *syms, *strings;
1517 bfd_size_type symsize, stringsize;
1518 asection *stabsec, *stabstrsec;
1520 if (! write_stabs_in_sections_debugging_info (obfd, dhandle, &syms,
1525 stabsec = bfd_make_section (obfd, ".stab");
1526 stabstrsec = bfd_make_section (obfd, ".stabstr");
1528 || stabstrsec == NULL
1529 || ! bfd_set_section_size (obfd, stabsec, symsize)
1530 || ! bfd_set_section_size (obfd, stabstrsec, stringsize)
1531 || ! bfd_set_section_alignment (obfd, stabsec, 2)
1532 || ! bfd_set_section_alignment (obfd, stabstrsec, 0)
1533 || ! bfd_set_section_flags (obfd, stabsec,
1537 || ! bfd_set_section_flags (obfd, stabstrsec,
1542 non_fatal (_("%s: can't create debugging section: %s"),
1543 bfd_get_filename (obfd),
1544 bfd_errmsg (bfd_get_error ()));
1548 /* We can get away with setting the section contents now because
1549 the next thing the caller is going to do is copy over the
1550 real sections. We may someday have to split the contents
1551 setting out of this function. */
1552 if (! bfd_set_section_contents (obfd, stabsec, syms, (file_ptr) 0,
1554 || ! bfd_set_section_contents (obfd, stabstrsec, strings,
1555 (file_ptr) 0, stringsize))
1557 non_fatal (_("%s: can't set debugging section contents: %s"),
1558 bfd_get_filename (obfd),
1559 bfd_errmsg (bfd_get_error ()));
1566 non_fatal (_("%s: don't know how to write debugging information for %s"),
1567 bfd_get_filename (obfd), bfd_get_target (obfd));
1572 strip_main (argc, argv)
1576 char *input_target = NULL, *output_target = NULL;
1577 boolean show_version = false;
1579 struct section_list *p;
1580 char *output_file = NULL;
1582 while ((c = getopt_long (argc, argv, "I:O:F:K:N:R:o:sSpgxXVv",
1583 strip_options, (int *) 0)) != EOF)
1588 input_target = optarg;
1591 output_target = optarg;
1594 input_target = output_target = optarg;
1597 p = find_section_list (optarg, true);
1599 sections_removed = true;
1602 strip_symbols = STRIP_ALL;
1606 strip_symbols = STRIP_DEBUG;
1608 case OPTION_STRIP_UNNEEDED:
1609 strip_symbols = STRIP_UNNEEDED;
1612 add_specific_symbol (optarg, &keep_specific_list);
1615 add_specific_symbol (optarg, &strip_specific_list);
1618 output_file = optarg;
1621 preserve_dates = true;
1624 discard_locals = LOCALS_ALL;
1627 discard_locals = LOCALS_START_L;
1633 show_version = true;
1636 break; /* we've been given a long option */
1638 strip_usage (stdout, 0);
1640 strip_usage (stderr, 1);
1645 print_version ("strip");
1647 /* Default is to strip all symbols. */
1648 if (strip_symbols == STRIP_UNDEF
1649 && discard_locals == LOCALS_UNDEF
1650 && strip_specific_list == NULL)
1651 strip_symbols = STRIP_ALL;
1653 if (output_target == (char *) NULL)
1654 output_target = input_target;
1658 || (output_file != NULL && (i + 1) < argc))
1659 strip_usage (stderr, 1);
1661 for (; i < argc; i++)
1663 int hold_status = status;
1664 struct stat statbuf;
1669 if (stat (argv[i], &statbuf) < 0)
1671 non_fatal (_("%s: cannot stat: %s"), argv[i], strerror (errno));
1676 if (output_file != NULL)
1677 tmpname = output_file;
1679 tmpname = make_tempname (argv[i]);
1682 copy_file (argv[i], tmpname, input_target, output_target);
1686 set_times (tmpname, &statbuf);
1687 if (output_file == NULL)
1688 smart_rename (tmpname, argv[i], preserve_dates);
1689 status = hold_status;
1693 if (output_file == NULL)
1701 copy_main (argc, argv)
1705 char *input_filename = NULL, *output_filename = NULL;
1706 char *input_target = NULL, *output_target = NULL;
1707 boolean show_version = false;
1708 boolean change_warn = true;
1710 struct section_list *p;
1711 struct stat statbuf;
1713 while ((c = getopt_long (argc, argv, "b:i:I:j:K:N:s:O:d:F:L:R:SpgxXVvW:",
1714 copy_options, (int *) 0)) != EOF)
1719 copy_byte = atoi (optarg);
1721 fatal (_("byte number must be non-negative"));
1724 interleave = atoi (optarg);
1726 fatal (_("interleave must be positive"));
1729 case 's': /* "source" - 'I' is preferred */
1730 input_target = optarg;
1733 case 'd': /* "destination" - 'O' is preferred */
1734 output_target = optarg;
1737 input_target = output_target = optarg;
1740 p = find_section_list (optarg, true);
1742 fatal (_("%s both copied and removed"), optarg);
1744 sections_copied = true;
1747 p = find_section_list (optarg, true);
1749 fatal (_("%s both copied and removed"), optarg);
1751 sections_removed = true;
1754 strip_symbols = STRIP_ALL;
1757 strip_symbols = STRIP_DEBUG;
1759 case OPTION_STRIP_UNNEEDED:
1760 strip_symbols = STRIP_UNNEEDED;
1763 add_specific_symbol (optarg, &keep_specific_list);
1766 add_specific_symbol (optarg, &strip_specific_list);
1769 add_specific_symbol (optarg, &localize_specific_list);
1772 add_specific_symbol (optarg, &weaken_specific_list);
1775 preserve_dates = true;
1778 discard_locals = LOCALS_ALL;
1781 discard_locals = LOCALS_START_L;
1787 show_version = true;
1792 case OPTION_ADD_SECTION:
1796 struct section_add *pa;
1801 s = strchr (optarg, '=');
1804 fatal (_("bad format for --add-section NAME=FILENAME"));
1806 if (stat (s + 1, & st) < 0)
1807 fatal (_("cannot stat: %s: %s"), s + 1, strerror (errno));
1809 pa = (struct section_add *) xmalloc (sizeof (struct section_add));
1812 name = (char *) xmalloc (len + 1);
1813 strncpy (name, optarg, len);
1817 pa->filename = s + 1;
1819 pa->size = st.st_size;
1821 pa->contents = (bfd_byte *) xmalloc (pa->size);
1822 f = fopen (pa->filename, FOPEN_RB);
1825 fatal (_("cannot open: %s: %s"), pa->filename, strerror (errno));
1827 if (fread (pa->contents, 1, pa->size, f) == 0
1829 fatal (_("%s: fread failed"), pa->filename);
1833 pa->next = add_sections;
1837 case OPTION_CHANGE_START:
1838 change_start = parse_vma (optarg, "--change-start");
1840 case OPTION_CHANGE_SECTION_ADDRESS:
1841 case OPTION_CHANGE_SECTION_LMA:
1842 case OPTION_CHANGE_SECTION_VMA:
1847 char *option = NULL;
1849 enum change_action what = CHANGE_IGNORE;
1853 case OPTION_CHANGE_SECTION_ADDRESS:
1854 option = "--change-section-address";
1856 case OPTION_CHANGE_SECTION_LMA:
1857 option = "--change-section-lma";
1859 case OPTION_CHANGE_SECTION_VMA:
1860 option = "--change-section-vma";
1864 s = strchr (optarg, '=');
1867 s = strchr (optarg, '+');
1870 s = strchr (optarg, '-');
1872 fatal (_("bad format for %s"), option);
1877 name = (char *) xmalloc (len + 1);
1878 strncpy (name, optarg, len);
1881 p = find_section_list (name, true);
1883 val = parse_vma (s + 1, option);
1887 case '=': what = CHANGE_SET; break;
1888 case '-': val = - val; /* Drop through. */
1889 case '+': what = CHANGE_MODIFY; break;
1894 case OPTION_CHANGE_SECTION_ADDRESS:
1895 p->change_vma = what;
1899 case OPTION_CHANGE_SECTION_LMA:
1900 p->change_lma = what;
1904 case OPTION_CHANGE_SECTION_VMA:
1905 p->change_vma = what;
1911 case OPTION_CHANGE_ADDRESSES:
1912 change_section_address = parse_vma (optarg, "--change-addresses");
1913 change_start = change_section_address;
1915 case OPTION_CHANGE_WARNINGS:
1918 case OPTION_CHANGE_LEADING_CHAR:
1919 change_leading_char = true;
1921 case OPTION_DEBUGGING:
1922 convert_debugging = true;
1924 case OPTION_GAP_FILL:
1926 bfd_vma gap_fill_vma;
1928 gap_fill_vma = parse_vma (optarg, "--gap-fill");
1929 gap_fill = (bfd_byte) gap_fill_vma;
1930 if ((bfd_vma) gap_fill != gap_fill_vma)
1934 sprintf_vma (buff, gap_fill_vma);
1936 non_fatal (_("Warning: truncating gap-fill from 0x%s to 0x%x"),
1939 gap_fill_set = true;
1942 case OPTION_NO_CHANGE_WARNINGS:
1943 change_warn = false;
1946 pad_to = parse_vma (optarg, "--pad-to");
1949 case OPTION_REMOVE_LEADING_CHAR:
1950 remove_leading_char = true;
1952 case OPTION_SET_SECTION_FLAGS:
1958 s = strchr (optarg, '=');
1960 fatal (_("bad format for --set-section-flags"));
1963 name = (char *) xmalloc (len + 1);
1964 strncpy (name, optarg, len);
1967 p = find_section_list (name, true);
1969 p->set_flags = true;
1970 p->flags = parse_flags (s + 1);
1973 case OPTION_SET_START:
1974 set_start = parse_vma (optarg, "--set-start");
1975 set_start_set = true;
1978 break; /* we've been given a long option */
1980 copy_usage (stdout, 0);
1982 copy_usage (stderr, 1);
1987 print_version ("objcopy");
1989 if (copy_byte >= interleave)
1990 fatal (_("byte number must be less than interleave"));
1992 if (optind == argc || optind + 2 < argc)
1993 copy_usage (stderr, 1);
1995 input_filename = argv[optind];
1996 if (optind + 1 < argc)
1997 output_filename = argv[optind + 1];
1999 /* Default is to strip no symbols. */
2000 if (strip_symbols == STRIP_UNDEF && discard_locals == LOCALS_UNDEF)
2001 strip_symbols = STRIP_NONE;
2003 if (output_target == (char *) NULL)
2004 output_target = input_target;
2008 if (stat (input_filename, &statbuf) < 0)
2009 fatal (_("Cannot stat: %s: %s"), input_filename, strerror (errno));
2012 /* If there is no destination file then create a temp and rename
2013 the result into the input. */
2015 if (output_filename == (char *) NULL)
2017 char *tmpname = make_tempname (input_filename);
2019 copy_file (input_filename, tmpname, input_target, output_target);
2023 set_times (tmpname, &statbuf);
2024 smart_rename (tmpname, input_filename, preserve_dates);
2031 copy_file (input_filename, output_filename, input_target, output_target);
2032 if (status == 0 && preserve_dates)
2033 set_times (output_filename, &statbuf);
2038 for (p = change_sections; p != NULL; p = p->next)
2042 if (p->change_vma != CHANGE_IGNORE)
2046 sprintf_vma (buff, p->vma_val);
2048 /* xgettext:c-format */
2049 non_fatal (_("Warning: --change-section-vma %s%c0x%s never used"),
2051 p->change_vma == CHANGE_SET ? '=' : '+',
2055 if (p->change_lma != CHANGE_IGNORE)
2059 sprintf_vma (buff, p->lma_val);
2061 /* xgettext:c-format */
2062 non_fatal (_("Warning: --change-section-lma %s%c0x%s never used"),
2064 p->change_lma == CHANGE_SET ? '=' : '+',
2079 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
2080 setlocale (LC_MESSAGES, "");
2082 bindtextdomain (PACKAGE, LOCALEDIR);
2083 textdomain (PACKAGE);
2085 program_name = argv[0];
2086 xmalloc_set_program_name (program_name);
2088 START_PROGRESS (program_name, 0);
2090 strip_symbols = STRIP_UNDEF;
2091 discard_locals = LOCALS_UNDEF;
2094 set_default_bfd_target ();
2098 int i = strlen (program_name);
2099 is_strip = (i >= 5 && strcmp (program_name + i - 5, "strip") == 0);
2103 strip_main (argc, argv);
2105 copy_main (argc, argv);
2107 END_PROGRESS (program_name);