PR bootstrap/30748
[binutils.git] / binutils / objcopy.c
blob70238dace33cdf02a39c768818c407ac23f4eec5
1 /* objcopy.c -- copy object file from input to output, optionally massaging it.
2 Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004, 2005, 2006
4 Free Software Foundation, Inc.
6 This file is part of GNU Binutils.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
21 02110-1301, USA. */
23 #include "bfd.h"
24 #include "progress.h"
25 #include "bucomm.h"
26 #include "getopt.h"
27 #include "libiberty.h"
28 #include "budbg.h"
29 #include "filenames.h"
30 #include "fnmatch.h"
31 #include "elf-bfd.h"
32 #include <sys/stat.h>
33 #include "libbfd.h"
35 /* A list of symbols to explicitly strip out, or to keep. A linked
36 list is good enough for a small number from the command line, but
37 this will slow things down a lot if many symbols are being
38 deleted. */
40 struct symlist
42 const char *name;
43 struct symlist *next;
46 /* A list to support redefine_sym. */
47 struct redefine_node
49 char *source;
50 char *target;
51 struct redefine_node *next;
54 typedef struct section_rename
56 const char * old_name;
57 const char * new_name;
58 flagword flags;
59 struct section_rename * next;
61 section_rename;
63 /* List of sections to be renamed. */
64 static section_rename *section_rename_list;
66 #define RETURN_NONFATAL(s) {bfd_nonfatal (s); status = 1; return;}
68 static asymbol **isympp = NULL; /* Input symbols. */
69 static asymbol **osympp = NULL; /* Output symbols that survive stripping. */
71 /* If `copy_byte' >= 0, copy only that byte of every `interleave' bytes. */
72 static int copy_byte = -1;
73 static int interleave = 4;
75 static bfd_boolean verbose; /* Print file and target names. */
76 static bfd_boolean preserve_dates; /* Preserve input file timestamp. */
77 static int status = 0; /* Exit status. */
79 enum strip_action
81 STRIP_UNDEF,
82 STRIP_NONE, /* Don't strip. */
83 STRIP_DEBUG, /* Strip all debugger symbols. */
84 STRIP_UNNEEDED, /* Strip unnecessary symbols. */
85 STRIP_NONDEBUG, /* Strip everything but debug info. */
86 STRIP_ALL /* Strip all symbols. */
89 /* Which symbols to remove. */
90 static enum strip_action strip_symbols;
92 enum locals_action
94 LOCALS_UNDEF,
95 LOCALS_START_L, /* Discard locals starting with L. */
96 LOCALS_ALL /* Discard all locals. */
99 /* Which local symbols to remove. Overrides STRIP_ALL. */
100 static enum locals_action discard_locals;
102 /* What kind of change to perform. */
103 enum change_action
105 CHANGE_IGNORE,
106 CHANGE_MODIFY,
107 CHANGE_SET
110 /* Structure used to hold lists of sections and actions to take. */
111 struct section_list
113 struct section_list * next; /* Next section to change. */
114 const char * name; /* Section name. */
115 bfd_boolean used; /* Whether this entry was used. */
116 bfd_boolean remove; /* Whether to remove this section. */
117 bfd_boolean copy; /* Whether to copy this section. */
118 enum change_action change_vma;/* Whether to change or set VMA. */
119 bfd_vma vma_val; /* Amount to change by or set to. */
120 enum change_action change_lma;/* Whether to change or set LMA. */
121 bfd_vma lma_val; /* Amount to change by or set to. */
122 bfd_boolean set_flags; /* Whether to set the section flags. */
123 flagword flags; /* What to set the section flags to. */
126 static struct section_list *change_sections;
128 /* TRUE if some sections are to be removed. */
129 static bfd_boolean sections_removed;
131 /* TRUE if only some sections are to be copied. */
132 static bfd_boolean sections_copied;
134 /* Changes to the start address. */
135 static bfd_vma change_start = 0;
136 static bfd_boolean set_start_set = FALSE;
137 static bfd_vma set_start;
139 /* Changes to section addresses. */
140 static bfd_vma change_section_address = 0;
142 /* Filling gaps between sections. */
143 static bfd_boolean gap_fill_set = FALSE;
144 static bfd_byte gap_fill = 0;
146 /* Pad to a given address. */
147 static bfd_boolean pad_to_set = FALSE;
148 static bfd_vma pad_to;
150 /* Use alternative machine code? */
151 static unsigned long use_alt_mach_code = 0;
153 /* Output BFD flags user wants to set or clear */
154 static flagword bfd_flags_to_set;
155 static flagword bfd_flags_to_clear;
157 /* List of sections to add. */
158 struct section_add
160 /* Next section to add. */
161 struct section_add *next;
162 /* Name of section to add. */
163 const char *name;
164 /* Name of file holding section contents. */
165 const char *filename;
166 /* Size of file. */
167 size_t size;
168 /* Contents of file. */
169 bfd_byte *contents;
170 /* BFD section, after it has been added. */
171 asection *section;
174 /* List of sections to add to the output BFD. */
175 static struct section_add *add_sections;
177 /* If non-NULL the argument to --add-gnu-debuglink.
178 This should be the filename to store in the .gnu_debuglink section. */
179 static const char * gnu_debuglink_filename = NULL;
181 /* Whether to convert debugging information. */
182 static bfd_boolean convert_debugging = FALSE;
184 /* Whether to change the leading character in symbol names. */
185 static bfd_boolean change_leading_char = FALSE;
187 /* Whether to remove the leading character from global symbol names. */
188 static bfd_boolean remove_leading_char = FALSE;
190 /* Whether to permit wildcard in symbol comparison. */
191 static bfd_boolean wildcard = FALSE;
193 /* True if --localize-hidden is in effect. */
194 static bfd_boolean localize_hidden = FALSE;
196 /* List of symbols to strip, keep, localize, keep-global, weaken,
197 or redefine. */
198 static struct symlist *strip_specific_list = NULL;
199 static struct symlist *strip_unneeded_list = NULL;
200 static struct symlist *keep_specific_list = NULL;
201 static struct symlist *localize_specific_list = NULL;
202 static struct symlist *globalize_specific_list = NULL;
203 static struct symlist *keepglobal_specific_list = NULL;
204 static struct symlist *weaken_specific_list = NULL;
205 static struct redefine_node *redefine_sym_list = NULL;
207 /* If this is TRUE, we weaken global symbols (set BSF_WEAK). */
208 static bfd_boolean weaken = FALSE;
210 /* If this is TRUE, we retain BSF_FILE symbols. */
211 static bfd_boolean keep_file_symbols = FALSE;
213 /* Prefix symbols/sections. */
214 static char *prefix_symbols_string = 0;
215 static char *prefix_sections_string = 0;
216 static char *prefix_alloc_sections_string = 0;
218 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
219 enum command_line_switch
221 OPTION_ADD_SECTION=150,
222 OPTION_CHANGE_ADDRESSES,
223 OPTION_CHANGE_LEADING_CHAR,
224 OPTION_CHANGE_START,
225 OPTION_CHANGE_SECTION_ADDRESS,
226 OPTION_CHANGE_SECTION_LMA,
227 OPTION_CHANGE_SECTION_VMA,
228 OPTION_CHANGE_WARNINGS,
229 OPTION_DEBUGGING,
230 OPTION_GAP_FILL,
231 OPTION_NO_CHANGE_WARNINGS,
232 OPTION_PAD_TO,
233 OPTION_REMOVE_LEADING_CHAR,
234 OPTION_SET_SECTION_FLAGS,
235 OPTION_SET_START,
236 OPTION_STRIP_UNNEEDED,
237 OPTION_WEAKEN,
238 OPTION_REDEFINE_SYM,
239 OPTION_REDEFINE_SYMS,
240 OPTION_SREC_LEN,
241 OPTION_SREC_FORCES3,
242 OPTION_STRIP_SYMBOLS,
243 OPTION_STRIP_UNNEEDED_SYMBOL,
244 OPTION_STRIP_UNNEEDED_SYMBOLS,
245 OPTION_KEEP_SYMBOLS,
246 OPTION_LOCALIZE_HIDDEN,
247 OPTION_LOCALIZE_SYMBOLS,
248 OPTION_GLOBALIZE_SYMBOL,
249 OPTION_GLOBALIZE_SYMBOLS,
250 OPTION_KEEPGLOBAL_SYMBOLS,
251 OPTION_WEAKEN_SYMBOLS,
252 OPTION_RENAME_SECTION,
253 OPTION_ALT_MACH_CODE,
254 OPTION_PREFIX_SYMBOLS,
255 OPTION_PREFIX_SECTIONS,
256 OPTION_PREFIX_ALLOC_SECTIONS,
257 OPTION_FORMATS_INFO,
258 OPTION_ADD_GNU_DEBUGLINK,
259 OPTION_ONLY_KEEP_DEBUG,
260 OPTION_KEEP_FILE_SYMBOLS,
261 OPTION_READONLY_TEXT,
262 OPTION_WRITABLE_TEXT,
263 OPTION_PURE,
264 OPTION_IMPURE
267 /* Options to handle if running as "strip". */
269 static struct option strip_options[] =
271 {"discard-all", no_argument, 0, 'x'},
272 {"discard-locals", no_argument, 0, 'X'},
273 {"format", required_argument, 0, 'F'}, /* Obsolete */
274 {"help", no_argument, 0, 'h'},
275 {"info", no_argument, 0, OPTION_FORMATS_INFO},
276 {"input-format", required_argument, 0, 'I'}, /* Obsolete */
277 {"input-target", required_argument, 0, 'I'},
278 {"keep-file-symbols", no_argument, 0, OPTION_KEEP_FILE_SYMBOLS},
279 {"keep-symbol", required_argument, 0, 'K'},
280 {"only-keep-debug", no_argument, 0, OPTION_ONLY_KEEP_DEBUG},
281 {"output-format", required_argument, 0, 'O'}, /* Obsolete */
282 {"output-target", required_argument, 0, 'O'},
283 {"output-file", required_argument, 0, 'o'},
284 {"preserve-dates", no_argument, 0, 'p'},
285 {"remove-section", required_argument, 0, 'R'},
286 {"strip-all", no_argument, 0, 's'},
287 {"strip-debug", no_argument, 0, 'S'},
288 {"strip-unneeded", no_argument, 0, OPTION_STRIP_UNNEEDED},
289 {"strip-symbol", required_argument, 0, 'N'},
290 {"target", required_argument, 0, 'F'},
291 {"verbose", no_argument, 0, 'v'},
292 {"version", no_argument, 0, 'V'},
293 {"wildcard", no_argument, 0, 'w'},
294 {0, no_argument, 0, 0}
297 /* Options to handle if running as "objcopy". */
299 static struct option copy_options[] =
301 {"add-gnu-debuglink", required_argument, 0, OPTION_ADD_GNU_DEBUGLINK},
302 {"add-section", required_argument, 0, OPTION_ADD_SECTION},
303 {"adjust-start", required_argument, 0, OPTION_CHANGE_START},
304 {"adjust-vma", required_argument, 0, OPTION_CHANGE_ADDRESSES},
305 {"adjust-section-vma", required_argument, 0, OPTION_CHANGE_SECTION_ADDRESS},
306 {"adjust-warnings", no_argument, 0, OPTION_CHANGE_WARNINGS},
307 {"alt-machine-code", required_argument, 0, OPTION_ALT_MACH_CODE},
308 {"binary-architecture", required_argument, 0, 'B'},
309 {"byte", required_argument, 0, 'b'},
310 {"change-addresses", required_argument, 0, OPTION_CHANGE_ADDRESSES},
311 {"change-leading-char", no_argument, 0, OPTION_CHANGE_LEADING_CHAR},
312 {"change-section-address", required_argument, 0, OPTION_CHANGE_SECTION_ADDRESS},
313 {"change-section-lma", required_argument, 0, OPTION_CHANGE_SECTION_LMA},
314 {"change-section-vma", required_argument, 0, OPTION_CHANGE_SECTION_VMA},
315 {"change-start", required_argument, 0, OPTION_CHANGE_START},
316 {"change-warnings", no_argument, 0, OPTION_CHANGE_WARNINGS},
317 {"debugging", no_argument, 0, OPTION_DEBUGGING},
318 {"discard-all", no_argument, 0, 'x'},
319 {"discard-locals", no_argument, 0, 'X'},
320 {"format", required_argument, 0, 'F'}, /* Obsolete */
321 {"gap-fill", required_argument, 0, OPTION_GAP_FILL},
322 {"globalize-symbol", required_argument, 0, OPTION_GLOBALIZE_SYMBOL},
323 {"globalize-symbols", required_argument, 0, OPTION_GLOBALIZE_SYMBOLS},
324 {"help", no_argument, 0, 'h'},
325 {"impure", no_argument, 0, OPTION_IMPURE},
326 {"info", no_argument, 0, OPTION_FORMATS_INFO},
327 {"input-format", required_argument, 0, 'I'}, /* Obsolete */
328 {"input-target", required_argument, 0, 'I'},
329 {"interleave", required_argument, 0, 'i'},
330 {"keep-file-symbols", no_argument, 0, OPTION_KEEP_FILE_SYMBOLS},
331 {"keep-global-symbol", required_argument, 0, 'G'},
332 {"keep-global-symbols", required_argument, 0, OPTION_KEEPGLOBAL_SYMBOLS},
333 {"keep-symbol", required_argument, 0, 'K'},
334 {"keep-symbols", required_argument, 0, OPTION_KEEP_SYMBOLS},
335 {"localize-hidden", no_argument, 0, OPTION_LOCALIZE_HIDDEN},
336 {"localize-symbol", required_argument, 0, 'L'},
337 {"localize-symbols", required_argument, 0, OPTION_LOCALIZE_SYMBOLS},
338 {"no-adjust-warnings", no_argument, 0, OPTION_NO_CHANGE_WARNINGS},
339 {"no-change-warnings", no_argument, 0, OPTION_NO_CHANGE_WARNINGS},
340 {"only-keep-debug", no_argument, 0, OPTION_ONLY_KEEP_DEBUG},
341 {"only-section", required_argument, 0, 'j'},
342 {"output-format", required_argument, 0, 'O'}, /* Obsolete */
343 {"output-target", required_argument, 0, 'O'},
344 {"pad-to", required_argument, 0, OPTION_PAD_TO},
345 {"prefix-symbols", required_argument, 0, OPTION_PREFIX_SYMBOLS},
346 {"prefix-sections", required_argument, 0, OPTION_PREFIX_SECTIONS},
347 {"prefix-alloc-sections", required_argument, 0, OPTION_PREFIX_ALLOC_SECTIONS},
348 {"preserve-dates", no_argument, 0, 'p'},
349 {"pure", no_argument, 0, OPTION_PURE},
350 {"readonly-text", no_argument, 0, OPTION_READONLY_TEXT},
351 {"redefine-sym", required_argument, 0, OPTION_REDEFINE_SYM},
352 {"redefine-syms", required_argument, 0, OPTION_REDEFINE_SYMS},
353 {"remove-leading-char", no_argument, 0, OPTION_REMOVE_LEADING_CHAR},
354 {"remove-section", required_argument, 0, 'R'},
355 {"rename-section", required_argument, 0, OPTION_RENAME_SECTION},
356 {"set-section-flags", required_argument, 0, OPTION_SET_SECTION_FLAGS},
357 {"set-start", required_argument, 0, OPTION_SET_START},
358 {"srec-len", required_argument, 0, OPTION_SREC_LEN},
359 {"srec-forceS3", no_argument, 0, OPTION_SREC_FORCES3},
360 {"strip-all", no_argument, 0, 'S'},
361 {"strip-debug", no_argument, 0, 'g'},
362 {"strip-unneeded", no_argument, 0, OPTION_STRIP_UNNEEDED},
363 {"strip-unneeded-symbol", required_argument, 0, OPTION_STRIP_UNNEEDED_SYMBOL},
364 {"strip-unneeded-symbols", required_argument, 0, OPTION_STRIP_UNNEEDED_SYMBOLS},
365 {"strip-symbol", required_argument, 0, 'N'},
366 {"strip-symbols", required_argument, 0, OPTION_STRIP_SYMBOLS},
367 {"target", required_argument, 0, 'F'},
368 {"verbose", no_argument, 0, 'v'},
369 {"version", no_argument, 0, 'V'},
370 {"weaken", no_argument, 0, OPTION_WEAKEN},
371 {"weaken-symbol", required_argument, 0, 'W'},
372 {"weaken-symbols", required_argument, 0, OPTION_WEAKEN_SYMBOLS},
373 {"wildcard", no_argument, 0, 'w'},
374 {"writable-text", no_argument, 0, OPTION_WRITABLE_TEXT},
375 {0, no_argument, 0, 0}
378 /* IMPORTS */
379 extern char *program_name;
381 /* This flag distinguishes between strip and objcopy:
382 1 means this is 'strip'; 0 means this is 'objcopy'.
383 -1 means if we should use argv[0] to decide. */
384 extern int is_strip;
386 /* The maximum length of an S record. This variable is declared in srec.c
387 and can be modified by the --srec-len parameter. */
388 extern unsigned int Chunk;
390 /* Restrict the generation of Srecords to type S3 only.
391 This variable is declare in bfd/srec.c and can be toggled
392 on by the --srec-forceS3 command line switch. */
393 extern bfd_boolean S3Forced;
395 /* Defined in bfd/binary.c. Used to set architecture and machine of input
396 binary files. */
397 extern enum bfd_architecture bfd_external_binary_architecture;
398 extern unsigned long bfd_external_machine;
400 /* Forward declarations. */
401 static void setup_section (bfd *, asection *, void *);
402 static void setup_bfd_headers (bfd *, bfd *);
403 static void copy_section (bfd *, asection *, void *);
404 static void get_sections (bfd *, asection *, void *);
405 static int compare_section_lma (const void *, const void *);
406 static void mark_symbols_used_in_relocations (bfd *, asection *, void *);
407 static bfd_boolean write_debugging_info (bfd *, void *, long *, asymbol ***);
408 static const char *lookup_sym_redefinition (const char *);
410 static void
411 copy_usage (FILE *stream, int exit_status)
413 fprintf (stream, _("Usage: %s [option(s)] in-file [out-file]\n"), program_name);
414 fprintf (stream, _(" Copies a binary file, possibly transforming it in the process\n"));
415 fprintf (stream, _(" The options are:\n"));
416 fprintf (stream, _("\
417 -I --input-target <bfdname> Assume input file is in format <bfdname>\n\
418 -O --output-target <bfdname> Create an output file in format <bfdname>\n\
419 -B --binary-architecture <arch> Set arch of output file, when input is binary\n\
420 -F --target <bfdname> Set both input and output format to <bfdname>\n\
421 --debugging Convert debugging information, if possible\n\
422 -p --preserve-dates Copy modified/access timestamps to the output\n\
423 -j --only-section <name> Only copy section <name> into the output\n\
424 --add-gnu-debuglink=<file> Add section .gnu_debuglink linking to <file>\n\
425 -R --remove-section <name> Remove section <name> from the output\n\
426 -S --strip-all Remove all symbol and relocation information\n\
427 -g --strip-debug Remove all debugging symbols & sections\n\
428 --strip-unneeded Remove all symbols not needed by relocations\n\
429 -N --strip-symbol <name> Do not copy symbol <name>\n\
430 --strip-unneeded-symbol <name>\n\
431 Do not copy symbol <name> unless needed by\n\
432 relocations\n\
433 --only-keep-debug Strip everything but the debug information\n\
434 -K --keep-symbol <name> Do not strip symbol <name>\n\
435 --keep-file-symbols Do not strip file symbol(s)\n\
436 --localize-hidden Turn all ELF hidden symbols into locals\n\
437 -L --localize-symbol <name> Force symbol <name> to be marked as a local\n\
438 --globalize-symbol <name> Force symbol <name> to be marked as a global\n\
439 -G --keep-global-symbol <name> Localize all symbols except <name>\n\
440 -W --weaken-symbol <name> Force symbol <name> to be marked as a weak\n\
441 --weaken Force all global symbols to be marked as weak\n\
442 -w --wildcard Permit wildcard in symbol comparison\n\
443 -x --discard-all Remove all non-global symbols\n\
444 -X --discard-locals Remove any compiler-generated symbols\n\
445 -i --interleave <number> Only copy one out of every <number> bytes\n\
446 -b --byte <num> Select byte <num> in every interleaved block\n\
447 --gap-fill <val> Fill gaps between sections with <val>\n\
448 --pad-to <addr> Pad the last section up to address <addr>\n\
449 --set-start <addr> Set the start address to <addr>\n\
450 {--change-start|--adjust-start} <incr>\n\
451 Add <incr> to the start address\n\
452 {--change-addresses|--adjust-vma} <incr>\n\
453 Add <incr> to LMA, VMA and start addresses\n\
454 {--change-section-address|--adjust-section-vma} <name>{=|+|-}<val>\n\
455 Change LMA and VMA of section <name> by <val>\n\
456 --change-section-lma <name>{=|+|-}<val>\n\
457 Change the LMA of section <name> by <val>\n\
458 --change-section-vma <name>{=|+|-}<val>\n\
459 Change the VMA of section <name> by <val>\n\
460 {--[no-]change-warnings|--[no-]adjust-warnings}\n\
461 Warn if a named section does not exist\n\
462 --set-section-flags <name>=<flags>\n\
463 Set section <name>'s properties to <flags>\n\
464 --add-section <name>=<file> Add section <name> found in <file> to output\n\
465 --rename-section <old>=<new>[,<flags>] Rename section <old> to <new>\n\
466 --change-leading-char Force output format's leading character style\n\
467 --remove-leading-char Remove leading character from global symbols\n\
468 --redefine-sym <old>=<new> Redefine symbol name <old> to <new>\n\
469 --redefine-syms <file> --redefine-sym for all symbol pairs \n\
470 listed in <file>\n\
471 --srec-len <number> Restrict the length of generated Srecords\n\
472 --srec-forceS3 Restrict the type of generated Srecords to S3\n\
473 --strip-symbols <file> -N for all symbols listed in <file>\n\
474 --strip-unneeded-symbols <file>\n\
475 --strip-unneeded-symbol for all symbols listed\n\
476 in <file>\n\
477 --keep-symbols <file> -K for all symbols listed in <file>\n\
478 --localize-symbols <file> -L for all symbols listed in <file>\n\
479 --globalize-symbols <file> --globalize-symbol for all in <file>\n\
480 --keep-global-symbols <file> -G for all symbols listed in <file>\n\
481 --weaken-symbols <file> -W for all symbols listed in <file>\n\
482 --alt-machine-code <index> Use the target's <index>'th alternative machine\n\
483 --writable-text Mark the output text as writable\n\
484 --readonly-text Make the output text write protected\n\
485 --pure Mark the output file as demand paged\n\
486 --impure Mark the output file as impure\n\
487 --prefix-symbols <prefix> Add <prefix> to start of every symbol name\n\
488 --prefix-sections <prefix> Add <prefix> to start of every section name\n\
489 --prefix-alloc-sections <prefix>\n\
490 Add <prefix> to start of every allocatable\n\
491 section name\n\
492 -v --verbose List all object files modified\n\
493 @<file> Read options from <file>\n\
494 -V --version Display this program's version number\n\
495 -h --help Display this output\n\
496 --info List object formats & architectures supported\n\
497 "));
498 list_supported_targets (program_name, stream);
499 if (exit_status == 0)
500 fprintf (stream, _("Report bugs to %s\n"), REPORT_BUGS_TO);
501 exit (exit_status);
504 static void
505 strip_usage (FILE *stream, int exit_status)
507 fprintf (stream, _("Usage: %s <option(s)> in-file(s)\n"), program_name);
508 fprintf (stream, _(" Removes symbols and sections from files\n"));
509 fprintf (stream, _(" The options are:\n"));
510 fprintf (stream, _("\
511 -I --input-target=<bfdname> Assume input file is in format <bfdname>\n\
512 -O --output-target=<bfdname> Create an output file in format <bfdname>\n\
513 -F --target=<bfdname> Set both input and output format to <bfdname>\n\
514 -p --preserve-dates Copy modified/access timestamps to the output\n\
515 -R --remove-section=<name> Remove section <name> from the output\n\
516 -s --strip-all Remove all symbol and relocation information\n\
517 -g -S -d --strip-debug Remove all debugging symbols & sections\n\
518 --strip-unneeded Remove all symbols not needed by relocations\n\
519 --only-keep-debug Strip everything but the debug information\n\
520 -N --strip-symbol=<name> Do not copy symbol <name>\n\
521 -K --keep-symbol=<name> Do not strip symbol <name>\n\
522 --keep-file-symbols Do not strip file symbol(s)\n\
523 -w --wildcard Permit wildcard in symbol comparison\n\
524 -x --discard-all Remove all non-global symbols\n\
525 -X --discard-locals Remove any compiler-generated symbols\n\
526 -v --verbose List all object files modified\n\
527 -V --version Display this program's version number\n\
528 -h --help Display this output\n\
529 --info List object formats & architectures supported\n\
530 -o <file> Place stripped output into <file>\n\
531 "));
533 list_supported_targets (program_name, stream);
534 if (exit_status == 0)
535 fprintf (stream, _("Report bugs to %s\n"), REPORT_BUGS_TO);
536 exit (exit_status);
539 /* Parse section flags into a flagword, with a fatal error if the
540 string can't be parsed. */
542 static flagword
543 parse_flags (const char *s)
545 flagword ret;
546 const char *snext;
547 int len;
549 ret = SEC_NO_FLAGS;
553 snext = strchr (s, ',');
554 if (snext == NULL)
555 len = strlen (s);
556 else
558 len = snext - s;
559 ++snext;
562 if (0) ;
563 #define PARSE_FLAG(fname,fval) \
564 else if (strncasecmp (fname, s, len) == 0) ret |= fval
565 PARSE_FLAG ("alloc", SEC_ALLOC);
566 PARSE_FLAG ("load", SEC_LOAD);
567 PARSE_FLAG ("noload", SEC_NEVER_LOAD);
568 PARSE_FLAG ("readonly", SEC_READONLY);
569 PARSE_FLAG ("debug", SEC_DEBUGGING);
570 PARSE_FLAG ("code", SEC_CODE);
571 PARSE_FLAG ("data", SEC_DATA);
572 PARSE_FLAG ("rom", SEC_ROM);
573 PARSE_FLAG ("share", SEC_COFF_SHARED);
574 PARSE_FLAG ("contents", SEC_HAS_CONTENTS);
575 #undef PARSE_FLAG
576 else
578 char *copy;
580 copy = xmalloc (len + 1);
581 strncpy (copy, s, len);
582 copy[len] = '\0';
583 non_fatal (_("unrecognized section flag `%s'"), copy);
584 fatal (_("supported flags: %s"),
585 "alloc, load, noload, readonly, debug, code, data, rom, share, contents");
588 s = snext;
590 while (s != NULL);
592 return ret;
595 /* Find and optionally add an entry in the change_sections list. */
597 static struct section_list *
598 find_section_list (const char *name, bfd_boolean add)
600 struct section_list *p;
602 for (p = change_sections; p != NULL; p = p->next)
603 if (strcmp (p->name, name) == 0)
604 return p;
606 if (! add)
607 return NULL;
609 p = xmalloc (sizeof (struct section_list));
610 p->name = name;
611 p->used = FALSE;
612 p->remove = FALSE;
613 p->copy = FALSE;
614 p->change_vma = CHANGE_IGNORE;
615 p->change_lma = CHANGE_IGNORE;
616 p->vma_val = 0;
617 p->lma_val = 0;
618 p->set_flags = FALSE;
619 p->flags = 0;
621 p->next = change_sections;
622 change_sections = p;
624 return p;
627 /* Add a symbol to strip_specific_list. */
629 static void
630 add_specific_symbol (const char *name, struct symlist **list)
632 struct symlist *tmp_list;
634 tmp_list = xmalloc (sizeof (struct symlist));
635 tmp_list->name = name;
636 tmp_list->next = *list;
637 *list = tmp_list;
640 /* Add symbols listed in `filename' to strip_specific_list. */
642 #define IS_WHITESPACE(c) ((c) == ' ' || (c) == '\t')
643 #define IS_LINE_TERMINATOR(c) ((c) == '\n' || (c) == '\r' || (c) == '\0')
645 static void
646 add_specific_symbols (const char *filename, struct symlist **list)
648 off_t size;
649 FILE * f;
650 char * line;
651 char * buffer;
652 unsigned int line_count;
654 size = get_file_size (filename);
655 if (size == 0)
657 status = 1;
658 return;
661 buffer = xmalloc (size + 2);
662 f = fopen (filename, FOPEN_RT);
663 if (f == NULL)
664 fatal (_("cannot open '%s': %s"), filename, strerror (errno));
666 if (fread (buffer, 1, size, f) == 0 || ferror (f))
667 fatal (_("%s: fread failed"), filename);
669 fclose (f);
670 buffer [size] = '\n';
671 buffer [size + 1] = '\0';
673 line_count = 1;
675 for (line = buffer; * line != '\0'; line ++)
677 char * eol;
678 char * name;
679 char * name_end;
680 int finished = FALSE;
682 for (eol = line;; eol ++)
684 switch (* eol)
686 case '\n':
687 * eol = '\0';
688 /* Cope with \n\r. */
689 if (eol[1] == '\r')
690 ++ eol;
691 finished = TRUE;
692 break;
694 case '\r':
695 * eol = '\0';
696 /* Cope with \r\n. */
697 if (eol[1] == '\n')
698 ++ eol;
699 finished = TRUE;
700 break;
702 case 0:
703 finished = TRUE;
704 break;
706 case '#':
707 /* Line comment, Terminate the line here, in case a
708 name is present and then allow the rest of the
709 loop to find the real end of the line. */
710 * eol = '\0';
711 break;
713 default:
714 break;
717 if (finished)
718 break;
721 /* A name may now exist somewhere between 'line' and 'eol'.
722 Strip off leading whitespace and trailing whitespace,
723 then add it to the list. */
724 for (name = line; IS_WHITESPACE (* name); name ++)
726 for (name_end = name;
727 (! IS_WHITESPACE (* name_end))
728 && (! IS_LINE_TERMINATOR (* name_end));
729 name_end ++)
732 if (! IS_LINE_TERMINATOR (* name_end))
734 char * extra;
736 for (extra = name_end + 1; IS_WHITESPACE (* extra); extra ++)
739 if (! IS_LINE_TERMINATOR (* extra))
740 non_fatal (_("%s:%d: Ignoring rubbish found on this line"),
741 filename, line_count);
744 * name_end = '\0';
746 if (name_end > name)
747 add_specific_symbol (name, list);
749 /* Advance line pointer to end of line. The 'eol ++' in the for
750 loop above will then advance us to the start of the next line. */
751 line = eol;
752 line_count ++;
756 /* See whether a symbol should be stripped or kept based on
757 strip_specific_list and keep_symbols. */
759 static bfd_boolean
760 is_specified_symbol (const char *name, struct symlist *list)
762 struct symlist *tmp_list;
764 if (wildcard)
766 for (tmp_list = list; tmp_list; tmp_list = tmp_list->next)
767 if (*(tmp_list->name) != '!')
769 if (!fnmatch (tmp_list->name, name, 0))
770 return TRUE;
772 else
774 if (fnmatch (tmp_list->name + 1, name, 0))
775 return TRUE;
778 else
780 for (tmp_list = list; tmp_list; tmp_list = tmp_list->next)
781 if (strcmp (name, tmp_list->name) == 0)
782 return TRUE;
785 return FALSE;
788 /* Return a pointer to the symbol used as a signature for GROUP. */
790 static asymbol *
791 group_signature (asection *group)
793 bfd *abfd = group->owner;
794 Elf_Internal_Shdr *ghdr;
796 if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
797 return NULL;
799 ghdr = &elf_section_data (group)->this_hdr;
800 if (ghdr->sh_link < elf_numsections (abfd))
802 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
803 Elf_Internal_Shdr *symhdr = elf_elfsections (abfd) [ghdr->sh_link];
805 if (symhdr->sh_type == SHT_SYMTAB
806 && ghdr->sh_info < symhdr->sh_size / bed->s->sizeof_sym)
807 return isympp[ghdr->sh_info - 1];
809 return NULL;
812 /* See if a section is being removed. */
814 static bfd_boolean
815 is_strip_section (bfd *abfd ATTRIBUTE_UNUSED, asection *sec)
817 if (sections_removed || sections_copied)
819 struct section_list *p;
821 p = find_section_list (bfd_get_section_name (abfd, sec), FALSE);
823 if (sections_removed && p != NULL && p->remove)
824 return TRUE;
825 if (sections_copied && (p == NULL || ! p->copy))
826 return TRUE;
829 if ((bfd_get_section_flags (abfd, sec) & SEC_DEBUGGING) != 0)
831 if (strip_symbols == STRIP_DEBUG
832 || strip_symbols == STRIP_UNNEEDED
833 || strip_symbols == STRIP_ALL
834 || discard_locals == LOCALS_ALL
835 || convert_debugging)
836 return TRUE;
838 if (strip_symbols == STRIP_NONDEBUG)
839 return FALSE;
842 if ((bfd_get_section_flags (abfd, sec) & SEC_GROUP) != 0)
844 asymbol *gsym;
845 const char *gname;
847 /* PR binutils/3166
848 Group sections look like debugging sections but they are not.
849 (They have a non-zero size but they are not ALLOCated). */
850 if (strip_symbols == STRIP_NONDEBUG)
851 return TRUE;
853 /* PR binutils/3181
854 If we are going to strip the group signature symbol, then
855 strip the group section too. */
856 gsym = group_signature (sec);
857 if (gsym != NULL)
858 gname = gsym->name;
859 else
860 gname = sec->name;
861 if ((strip_symbols == STRIP_ALL
862 && !is_specified_symbol (gname, keep_specific_list))
863 || is_specified_symbol (gname, strip_specific_list))
864 return TRUE;
867 return FALSE;
870 /* Return true if SYM is a hidden symbol. */
872 static bfd_boolean
873 is_hidden_symbol (asymbol *sym)
875 elf_symbol_type *elf_sym;
877 elf_sym = elf_symbol_from (sym->the_bfd, sym);
878 if (elf_sym != NULL)
879 switch (ELF_ST_VISIBILITY (elf_sym->internal_elf_sym.st_other))
881 case STV_HIDDEN:
882 case STV_INTERNAL:
883 return TRUE;
885 return FALSE;
888 /* Choose which symbol entries to copy; put the result in OSYMS.
889 We don't copy in place, because that confuses the relocs.
890 Return the number of symbols to print. */
892 static unsigned int
893 filter_symbols (bfd *abfd, bfd *obfd, asymbol **osyms,
894 asymbol **isyms, long symcount)
896 asymbol **from = isyms, **to = osyms;
897 long src_count = 0, dst_count = 0;
898 int relocatable = (abfd->flags & (HAS_RELOC | EXEC_P | DYNAMIC))
899 == HAS_RELOC;
901 for (; src_count < symcount; src_count++)
903 asymbol *sym = from[src_count];
904 flagword flags = sym->flags;
905 char *name = (char *) bfd_asymbol_name (sym);
906 int keep;
907 bfd_boolean undefined;
908 bfd_boolean rem_leading_char;
909 bfd_boolean add_leading_char;
911 undefined = bfd_is_und_section (bfd_get_section (sym));
913 if (redefine_sym_list)
915 char *old_name, *new_name;
917 old_name = (char *) bfd_asymbol_name (sym);
918 new_name = (char *) lookup_sym_redefinition (old_name);
919 bfd_asymbol_name (sym) = new_name;
920 name = new_name;
923 /* Check if we will remove the current leading character. */
924 rem_leading_char =
925 (name[0] == bfd_get_symbol_leading_char (abfd))
926 && (change_leading_char
927 || (remove_leading_char
928 && ((flags & (BSF_GLOBAL | BSF_WEAK)) != 0
929 || undefined
930 || bfd_is_com_section (bfd_get_section (sym)))));
932 /* Check if we will add a new leading character. */
933 add_leading_char =
934 change_leading_char
935 && (bfd_get_symbol_leading_char (obfd) != '\0')
936 && (bfd_get_symbol_leading_char (abfd) == '\0'
937 || (name[0] == bfd_get_symbol_leading_char (abfd)));
939 /* Short circuit for change_leading_char if we can do it in-place. */
940 if (rem_leading_char && add_leading_char && !prefix_symbols_string)
942 name[0] = bfd_get_symbol_leading_char (obfd);
943 bfd_asymbol_name (sym) = name;
944 rem_leading_char = FALSE;
945 add_leading_char = FALSE;
948 /* Remove leading char. */
949 if (rem_leading_char)
950 bfd_asymbol_name (sym) = ++name;
952 /* Add new leading char and/or prefix. */
953 if (add_leading_char || prefix_symbols_string)
955 char *n, *ptr;
957 ptr = n = xmalloc (1 + strlen (prefix_symbols_string)
958 + strlen (name) + 1);
959 if (add_leading_char)
960 *ptr++ = bfd_get_symbol_leading_char (obfd);
962 if (prefix_symbols_string)
964 strcpy (ptr, prefix_symbols_string);
965 ptr += strlen (prefix_symbols_string);
968 strcpy (ptr, name);
969 bfd_asymbol_name (sym) = n;
970 name = n;
973 if (strip_symbols == STRIP_ALL)
974 keep = 0;
975 else if ((flags & BSF_KEEP) != 0 /* Used in relocation. */
976 || ((flags & BSF_SECTION_SYM) != 0
977 && ((*bfd_get_section (sym)->symbol_ptr_ptr)->flags
978 & BSF_KEEP) != 0))
979 keep = 1;
980 else if (relocatable /* Relocatable file. */
981 && (flags & (BSF_GLOBAL | BSF_WEAK)) != 0)
982 keep = 1;
983 else if (bfd_decode_symclass (sym) == 'I')
984 /* Global symbols in $idata sections need to be retained
985 even if relocatable is FALSE. External users of the
986 library containing the $idata section may reference these
987 symbols. */
988 keep = 1;
989 else if ((flags & BSF_GLOBAL) != 0 /* Global symbol. */
990 || (flags & BSF_WEAK) != 0
991 || undefined
992 || bfd_is_com_section (bfd_get_section (sym)))
993 keep = strip_symbols != STRIP_UNNEEDED;
994 else if ((flags & BSF_DEBUGGING) != 0) /* Debugging symbol. */
995 keep = (strip_symbols != STRIP_DEBUG
996 && strip_symbols != STRIP_UNNEEDED
997 && ! convert_debugging);
998 else if (bfd_coff_get_comdat_section (abfd, bfd_get_section (sym)))
999 /* COMDAT sections store special information in local
1000 symbols, so we cannot risk stripping any of them. */
1001 keep = 1;
1002 else /* Local symbol. */
1003 keep = (strip_symbols != STRIP_UNNEEDED
1004 && (discard_locals != LOCALS_ALL
1005 && (discard_locals != LOCALS_START_L
1006 || ! bfd_is_local_label (abfd, sym))));
1008 if (keep && is_specified_symbol (name, strip_specific_list))
1009 keep = 0;
1010 if (keep
1011 && !(flags & BSF_KEEP)
1012 && is_specified_symbol (name, strip_unneeded_list))
1013 keep = 0;
1014 if (!keep
1015 && ((keep_file_symbols && (flags & BSF_FILE))
1016 || is_specified_symbol (name, keep_specific_list)))
1017 keep = 1;
1018 if (keep && is_strip_section (abfd, bfd_get_section (sym)))
1019 keep = 0;
1021 if (keep)
1023 if ((flags & BSF_GLOBAL) != 0
1024 && (weaken || is_specified_symbol (name, weaken_specific_list)))
1026 sym->flags &= ~ BSF_GLOBAL;
1027 sym->flags |= BSF_WEAK;
1030 if (!undefined
1031 && (flags & (BSF_GLOBAL | BSF_WEAK))
1032 && (is_specified_symbol (name, localize_specific_list)
1033 || (keepglobal_specific_list != NULL
1034 && ! is_specified_symbol (name, keepglobal_specific_list))
1035 || (localize_hidden && is_hidden_symbol (sym))))
1037 sym->flags &= ~ (BSF_GLOBAL | BSF_WEAK);
1038 sym->flags |= BSF_LOCAL;
1041 if (!undefined
1042 && (flags & BSF_LOCAL)
1043 && is_specified_symbol (name, globalize_specific_list))
1045 sym->flags &= ~ BSF_LOCAL;
1046 sym->flags |= BSF_GLOBAL;
1049 to[dst_count++] = sym;
1053 to[dst_count] = NULL;
1055 return dst_count;
1058 /* Find the redefined name of symbol SOURCE. */
1060 static const char *
1061 lookup_sym_redefinition (const char *source)
1063 struct redefine_node *list;
1065 for (list = redefine_sym_list; list != NULL; list = list->next)
1066 if (strcmp (source, list->source) == 0)
1067 return list->target;
1069 return source;
1072 /* Add a node to a symbol redefine list. */
1074 static void
1075 redefine_list_append (const char *cause, const char *source, const char *target)
1077 struct redefine_node **p;
1078 struct redefine_node *list;
1079 struct redefine_node *new_node;
1081 for (p = &redefine_sym_list; (list = *p) != NULL; p = &list->next)
1083 if (strcmp (source, list->source) == 0)
1084 fatal (_("%s: Multiple redefinition of symbol \"%s\""),
1085 cause, source);
1087 if (strcmp (target, list->target) == 0)
1088 fatal (_("%s: Symbol \"%s\" is target of more than one redefinition"),
1089 cause, target);
1092 new_node = xmalloc (sizeof (struct redefine_node));
1094 new_node->source = strdup (source);
1095 new_node->target = strdup (target);
1096 new_node->next = NULL;
1098 *p = new_node;
1101 /* Handle the --redefine-syms option. Read lines containing "old new"
1102 from the file, and add them to the symbol redefine list. */
1104 static void
1105 add_redefine_syms_file (const char *filename)
1107 FILE *file;
1108 char *buf;
1109 size_t bufsize;
1110 size_t len;
1111 size_t outsym_off;
1112 int c, lineno;
1114 file = fopen (filename, "r");
1115 if (file == NULL)
1116 fatal (_("couldn't open symbol redefinition file %s (error: %s)"),
1117 filename, strerror (errno));
1119 bufsize = 100;
1120 buf = xmalloc (bufsize);
1122 lineno = 1;
1123 c = getc (file);
1124 len = 0;
1125 outsym_off = 0;
1126 while (c != EOF)
1128 /* Collect the input symbol name. */
1129 while (! IS_WHITESPACE (c) && ! IS_LINE_TERMINATOR (c) && c != EOF)
1131 if (c == '#')
1132 goto comment;
1133 buf[len++] = c;
1134 if (len >= bufsize)
1136 bufsize *= 2;
1137 buf = xrealloc (buf, bufsize);
1139 c = getc (file);
1141 buf[len++] = '\0';
1142 if (c == EOF)
1143 break;
1145 /* Eat white space between the symbol names. */
1146 while (IS_WHITESPACE (c))
1147 c = getc (file);
1148 if (c == '#' || IS_LINE_TERMINATOR (c))
1149 goto comment;
1150 if (c == EOF)
1151 break;
1153 /* Collect the output symbol name. */
1154 outsym_off = len;
1155 while (! IS_WHITESPACE (c) && ! IS_LINE_TERMINATOR (c) && c != EOF)
1157 if (c == '#')
1158 goto comment;
1159 buf[len++] = c;
1160 if (len >= bufsize)
1162 bufsize *= 2;
1163 buf = xrealloc (buf, bufsize);
1165 c = getc (file);
1167 buf[len++] = '\0';
1168 if (c == EOF)
1169 break;
1171 /* Eat white space at end of line. */
1172 while (! IS_LINE_TERMINATOR(c) && c != EOF && IS_WHITESPACE (c))
1173 c = getc (file);
1174 if (c == '#')
1175 goto comment;
1176 /* Handle \r\n. */
1177 if ((c == '\r' && (c = getc (file)) == '\n')
1178 || c == '\n' || c == EOF)
1180 end_of_line:
1181 /* Append the redefinition to the list. */
1182 if (buf[0] != '\0')
1183 redefine_list_append (filename, &buf[0], &buf[outsym_off]);
1185 lineno++;
1186 len = 0;
1187 outsym_off = 0;
1188 if (c == EOF)
1189 break;
1190 c = getc (file);
1191 continue;
1193 else
1194 fatal (_("%s:%d: garbage found at end of line"), filename, lineno);
1195 comment:
1196 if (len != 0 && (outsym_off == 0 || outsym_off == len))
1197 fatal (_("%s:%d: missing new symbol name"), filename, lineno);
1198 buf[len++] = '\0';
1200 /* Eat the rest of the line and finish it. */
1201 while (c != '\n' && c != EOF)
1202 c = getc (file);
1203 goto end_of_line;
1206 if (len != 0)
1207 fatal (_("%s:%d: premature end of file"), filename, lineno);
1209 free (buf);
1212 /* Copy unkown object file IBFD onto OBFD.
1213 Returns TRUE upon success, FALSE otherwise. */
1215 static bfd_boolean
1216 copy_unknown_object (bfd *ibfd, bfd *obfd)
1218 char *cbuf;
1219 int tocopy;
1220 long ncopied;
1221 long size;
1222 struct stat buf;
1224 if (bfd_stat_arch_elt (ibfd, &buf) != 0)
1226 bfd_nonfatal (bfd_get_archive_filename (ibfd));
1227 return FALSE;
1230 size = buf.st_size;
1231 if (size < 0)
1233 non_fatal (_("stat returns negative size for `%s'"),
1234 bfd_get_archive_filename (ibfd));
1235 return FALSE;
1238 if (bfd_seek (ibfd, (file_ptr) 0, SEEK_SET) != 0)
1240 bfd_nonfatal (bfd_get_archive_filename (ibfd));
1241 return FALSE;
1244 if (verbose)
1245 printf (_("copy from `%s' [unknown] to `%s' [unknown]\n"),
1246 bfd_get_archive_filename (ibfd), bfd_get_filename (obfd));
1248 cbuf = xmalloc (BUFSIZE);
1249 ncopied = 0;
1250 while (ncopied < size)
1252 tocopy = size - ncopied;
1253 if (tocopy > BUFSIZE)
1254 tocopy = BUFSIZE;
1256 if (bfd_bread (cbuf, (bfd_size_type) tocopy, ibfd)
1257 != (bfd_size_type) tocopy)
1259 bfd_nonfatal (bfd_get_archive_filename (ibfd));
1260 free (cbuf);
1261 return FALSE;
1264 if (bfd_bwrite (cbuf, (bfd_size_type) tocopy, obfd)
1265 != (bfd_size_type) tocopy)
1267 bfd_nonfatal (bfd_get_filename (obfd));
1268 free (cbuf);
1269 return FALSE;
1272 ncopied += tocopy;
1275 chmod (bfd_get_filename (obfd), buf.st_mode);
1276 free (cbuf);
1277 return TRUE;
1280 /* Copy object file IBFD onto OBFD.
1281 Returns TRUE upon success, FALSE otherwise. */
1283 static bfd_boolean
1284 copy_object (bfd *ibfd, bfd *obfd)
1286 bfd_vma start;
1287 long symcount;
1288 asection **osections = NULL;
1289 asection *gnu_debuglink_section = NULL;
1290 bfd_size_type *gaps = NULL;
1291 bfd_size_type max_gap = 0;
1292 long symsize;
1293 void *dhandle;
1294 enum bfd_architecture iarch;
1295 unsigned int imach;
1297 if (ibfd->xvec->byteorder != obfd->xvec->byteorder
1298 && ibfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN
1299 && obfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN)
1300 fatal (_("Unable to change endianness of input file(s)"));
1302 if (!bfd_set_format (obfd, bfd_get_format (ibfd)))
1304 bfd_nonfatal (bfd_get_filename (obfd));
1305 return FALSE;
1308 if (verbose)
1309 printf (_("copy from `%s' [%s] to `%s' [%s]\n"),
1310 bfd_get_archive_filename (ibfd), bfd_get_target (ibfd),
1311 bfd_get_filename (obfd), bfd_get_target (obfd));
1313 if (set_start_set)
1314 start = set_start;
1315 else
1316 start = bfd_get_start_address (ibfd);
1317 start += change_start;
1319 /* Neither the start address nor the flags
1320 need to be set for a core file. */
1321 if (bfd_get_format (obfd) != bfd_core)
1323 flagword flags;
1325 flags = bfd_get_file_flags (ibfd);
1326 flags |= bfd_flags_to_set;
1327 flags &= ~bfd_flags_to_clear;
1328 flags &= bfd_applicable_file_flags (obfd);
1330 if (!bfd_set_start_address (obfd, start)
1331 || !bfd_set_file_flags (obfd, flags))
1333 bfd_nonfatal (bfd_get_archive_filename (ibfd));
1334 return FALSE;
1338 /* Copy architecture of input file to output file. */
1339 iarch = bfd_get_arch (ibfd);
1340 imach = bfd_get_mach (ibfd);
1341 if (!bfd_set_arch_mach (obfd, iarch, imach)
1342 && (ibfd->target_defaulted
1343 || bfd_get_arch (ibfd) != bfd_get_arch (obfd)))
1345 if (bfd_get_arch (ibfd) == bfd_arch_unknown)
1346 non_fatal (_("Unable to recognise the format of the input file `%s'"),
1347 bfd_get_archive_filename (ibfd));
1348 else
1349 non_fatal (_("Warning: Output file cannot represent architecture `%s'"),
1350 bfd_printable_arch_mach (bfd_get_arch (ibfd),
1351 bfd_get_mach (ibfd)));
1352 return FALSE;
1355 if (!bfd_set_format (obfd, bfd_get_format (ibfd)))
1357 bfd_nonfatal (bfd_get_archive_filename (ibfd));
1358 return FALSE;
1361 if (isympp)
1362 free (isympp);
1364 if (osympp != isympp)
1365 free (osympp);
1367 isympp = NULL;
1368 osympp = NULL;
1370 symsize = bfd_get_symtab_upper_bound (ibfd);
1371 if (symsize < 0)
1373 bfd_nonfatal (bfd_get_archive_filename (ibfd));
1374 return FALSE;
1377 osympp = isympp = xmalloc (symsize);
1378 symcount = bfd_canonicalize_symtab (ibfd, isympp);
1379 if (symcount < 0)
1381 bfd_nonfatal (bfd_get_filename (ibfd));
1382 return FALSE;
1385 /* BFD mandates that all output sections be created and sizes set before
1386 any output is done. Thus, we traverse all sections multiple times. */
1387 bfd_map_over_sections (ibfd, setup_section, obfd);
1389 setup_bfd_headers (ibfd, obfd);
1391 if (add_sections != NULL)
1393 struct section_add *padd;
1394 struct section_list *pset;
1396 for (padd = add_sections; padd != NULL; padd = padd->next)
1398 flagword flags;
1400 pset = find_section_list (padd->name, FALSE);
1401 if (pset != NULL)
1402 pset->used = TRUE;
1404 flags = SEC_HAS_CONTENTS | SEC_READONLY | SEC_DATA;
1405 if (pset != NULL && pset->set_flags)
1406 flags = pset->flags | SEC_HAS_CONTENTS;
1408 /* bfd_make_section_with_flags() does not return very helpful
1409 error codes, so check for the most likely user error first. */
1410 if (bfd_get_section_by_name (obfd, padd->name))
1412 non_fatal (_("can't add section '%s' - it already exists!"), padd->name);
1413 return FALSE;
1415 else
1417 padd->section = bfd_make_section_with_flags (obfd, padd->name, flags);
1418 if (padd->section == NULL)
1420 non_fatal (_("can't create section `%s': %s"),
1421 padd->name, bfd_errmsg (bfd_get_error ()));
1422 return FALSE;
1426 if (! bfd_set_section_size (obfd, padd->section, padd->size))
1428 bfd_nonfatal (bfd_get_filename (obfd));
1429 return FALSE;
1432 if (pset != NULL)
1434 if (pset->change_vma != CHANGE_IGNORE)
1435 if (! bfd_set_section_vma (obfd, padd->section,
1436 pset->vma_val))
1438 bfd_nonfatal (bfd_get_filename (obfd));
1439 return FALSE;
1442 if (pset->change_lma != CHANGE_IGNORE)
1444 padd->section->lma = pset->lma_val;
1446 if (! bfd_set_section_alignment
1447 (obfd, padd->section,
1448 bfd_section_alignment (obfd, padd->section)))
1450 bfd_nonfatal (bfd_get_filename (obfd));
1451 return FALSE;
1458 if (gnu_debuglink_filename != NULL)
1460 gnu_debuglink_section = bfd_create_gnu_debuglink_section
1461 (obfd, gnu_debuglink_filename);
1463 if (gnu_debuglink_section == NULL)
1465 bfd_nonfatal (gnu_debuglink_filename);
1466 return FALSE;
1469 /* Special processing for PE format files. We
1470 have no way to distinguish PE from COFF here. */
1471 if (bfd_get_flavour (obfd) == bfd_target_coff_flavour)
1473 bfd_vma debuglink_vma;
1474 asection * highest_section;
1475 asection * sec;
1477 /* The PE spec requires that all sections be adjacent and sorted
1478 in ascending order of VMA. It also specifies that debug
1479 sections should be last. This is despite the fact that debug
1480 sections are not loaded into memory and so in theory have no
1481 use for a VMA.
1483 This means that the debuglink section must be given a non-zero
1484 VMA which makes it contiguous with other debug sections. So
1485 walk the current section list, find the section with the
1486 highest VMA and start the debuglink section after that one. */
1487 for (sec = obfd->sections, highest_section = NULL;
1488 sec != NULL;
1489 sec = sec->next)
1490 if (sec->vma > 0
1491 && (highest_section == NULL
1492 || sec->vma > highest_section->vma))
1493 highest_section = sec;
1495 if (highest_section)
1496 debuglink_vma = BFD_ALIGN (highest_section->vma
1497 + highest_section->size,
1498 /* FIXME: We ought to be using
1499 COFF_PAGE_SIZE here or maybe
1500 bfd_get_section_alignment() (if it
1501 was set) but since this is for PE
1502 and we know the required alignment
1503 it is easier just to hard code it. */
1504 0x1000);
1505 else
1506 /* Umm, not sure what to do in this case. */
1507 debuglink_vma = 0x1000;
1509 bfd_set_section_vma (obfd, gnu_debuglink_section, debuglink_vma);
1513 if (bfd_count_sections (obfd) == 0)
1515 non_fatal (_("there are no sections to be copied!"));
1516 return FALSE;
1519 if (gap_fill_set || pad_to_set)
1521 asection **set;
1522 unsigned int c, i;
1524 /* We must fill in gaps between the sections and/or we must pad
1525 the last section to a specified address. We do this by
1526 grabbing a list of the sections, sorting them by VMA, and
1527 increasing the section sizes as required to fill the gaps.
1528 We write out the gap contents below. */
1530 c = bfd_count_sections (obfd);
1531 osections = xmalloc (c * sizeof (asection *));
1532 set = osections;
1533 bfd_map_over_sections (obfd, get_sections, &set);
1535 qsort (osections, c, sizeof (asection *), compare_section_lma);
1537 gaps = xmalloc (c * sizeof (bfd_size_type));
1538 memset (gaps, 0, c * sizeof (bfd_size_type));
1540 if (gap_fill_set)
1542 for (i = 0; i < c - 1; i++)
1544 flagword flags;
1545 bfd_size_type size;
1546 bfd_vma gap_start, gap_stop;
1548 flags = bfd_get_section_flags (obfd, osections[i]);
1549 if ((flags & SEC_HAS_CONTENTS) == 0
1550 || (flags & SEC_LOAD) == 0)
1551 continue;
1553 size = bfd_section_size (obfd, osections[i]);
1554 gap_start = bfd_section_lma (obfd, osections[i]) + size;
1555 gap_stop = bfd_section_lma (obfd, osections[i + 1]);
1556 if (gap_start < gap_stop)
1558 if (! bfd_set_section_size (obfd, osections[i],
1559 size + (gap_stop - gap_start)))
1561 non_fatal (_("Can't fill gap after %s: %s"),
1562 bfd_get_section_name (obfd, osections[i]),
1563 bfd_errmsg (bfd_get_error ()));
1564 status = 1;
1565 break;
1567 gaps[i] = gap_stop - gap_start;
1568 if (max_gap < gap_stop - gap_start)
1569 max_gap = gap_stop - gap_start;
1574 if (pad_to_set)
1576 bfd_vma lma;
1577 bfd_size_type size;
1579 lma = bfd_section_lma (obfd, osections[c - 1]);
1580 size = bfd_section_size (obfd, osections[c - 1]);
1581 if (lma + size < pad_to)
1583 if (! bfd_set_section_size (obfd, osections[c - 1],
1584 pad_to - lma))
1586 non_fatal (_("Can't add padding to %s: %s"),
1587 bfd_get_section_name (obfd, osections[c - 1]),
1588 bfd_errmsg (bfd_get_error ()));
1589 status = 1;
1591 else
1593 gaps[c - 1] = pad_to - (lma + size);
1594 if (max_gap < pad_to - (lma + size))
1595 max_gap = pad_to - (lma + size);
1601 /* Symbol filtering must happen after the output sections
1602 have been created, but before their contents are set. */
1603 dhandle = NULL;
1604 if (convert_debugging)
1605 dhandle = read_debugging_info (ibfd, isympp, symcount);
1607 if (strip_symbols == STRIP_DEBUG
1608 || strip_symbols == STRIP_ALL
1609 || strip_symbols == STRIP_UNNEEDED
1610 || strip_symbols == STRIP_NONDEBUG
1611 || discard_locals != LOCALS_UNDEF
1612 || localize_hidden
1613 || strip_specific_list != NULL
1614 || keep_specific_list != NULL
1615 || localize_specific_list != NULL
1616 || globalize_specific_list != NULL
1617 || keepglobal_specific_list != NULL
1618 || weaken_specific_list != NULL
1619 || prefix_symbols_string
1620 || sections_removed
1621 || sections_copied
1622 || convert_debugging
1623 || change_leading_char
1624 || remove_leading_char
1625 || redefine_sym_list
1626 || weaken)
1628 /* Mark symbols used in output relocations so that they
1629 are kept, even if they are local labels or static symbols.
1631 Note we iterate over the input sections examining their
1632 relocations since the relocations for the output sections
1633 haven't been set yet. mark_symbols_used_in_relocations will
1634 ignore input sections which have no corresponding output
1635 section. */
1636 if (strip_symbols != STRIP_ALL)
1637 bfd_map_over_sections (ibfd,
1638 mark_symbols_used_in_relocations,
1639 isympp);
1640 osympp = xmalloc ((symcount + 1) * sizeof (asymbol *));
1641 symcount = filter_symbols (ibfd, obfd, osympp, isympp, symcount);
1644 if (convert_debugging && dhandle != NULL)
1646 if (! write_debugging_info (obfd, dhandle, &symcount, &osympp))
1648 status = 1;
1649 return FALSE;
1653 bfd_set_symtab (obfd, osympp, symcount);
1655 /* This has to happen after the symbol table has been set. */
1656 bfd_map_over_sections (ibfd, copy_section, obfd);
1658 if (add_sections != NULL)
1660 struct section_add *padd;
1662 for (padd = add_sections; padd != NULL; padd = padd->next)
1664 if (! bfd_set_section_contents (obfd, padd->section, padd->contents,
1665 0, padd->size))
1667 bfd_nonfatal (bfd_get_filename (obfd));
1668 return FALSE;
1673 if (gnu_debuglink_filename != NULL)
1675 if (! bfd_fill_in_gnu_debuglink_section
1676 (obfd, gnu_debuglink_section, gnu_debuglink_filename))
1678 bfd_nonfatal (gnu_debuglink_filename);
1679 return FALSE;
1683 if (gap_fill_set || pad_to_set)
1685 bfd_byte *buf;
1686 int c, i;
1688 /* Fill in the gaps. */
1689 if (max_gap > 8192)
1690 max_gap = 8192;
1691 buf = xmalloc (max_gap);
1692 memset (buf, gap_fill, max_gap);
1694 c = bfd_count_sections (obfd);
1695 for (i = 0; i < c; i++)
1697 if (gaps[i] != 0)
1699 bfd_size_type left;
1700 file_ptr off;
1702 left = gaps[i];
1703 off = bfd_section_size (obfd, osections[i]) - left;
1705 while (left > 0)
1707 bfd_size_type now;
1709 if (left > 8192)
1710 now = 8192;
1711 else
1712 now = left;
1714 if (! bfd_set_section_contents (obfd, osections[i], buf,
1715 off, now))
1717 bfd_nonfatal (bfd_get_filename (obfd));
1718 return FALSE;
1721 left -= now;
1722 off += now;
1728 /* Allow the BFD backend to copy any private data it understands
1729 from the input BFD to the output BFD. This is done last to
1730 permit the routine to look at the filtered symbol table, which is
1731 important for the ECOFF code at least. */
1732 if (bfd_get_flavour (ibfd) == bfd_target_elf_flavour
1733 && strip_symbols == STRIP_NONDEBUG)
1734 /* Do not copy the private data when creating an ELF format
1735 debug info file. We do not want the program headers. */
1737 else if (! bfd_copy_private_bfd_data (ibfd, obfd))
1739 non_fatal (_("%s: error copying private BFD data: %s"),
1740 bfd_get_filename (obfd),
1741 bfd_errmsg (bfd_get_error ()));
1742 return FALSE;
1745 /* Switch to the alternate machine code. We have to do this at the
1746 very end, because we only initialize the header when we create
1747 the first section. */
1748 if (use_alt_mach_code != 0)
1750 if (! bfd_alt_mach_code (obfd, use_alt_mach_code))
1752 non_fatal (_("this target does not support %lu alternative machine codes"),
1753 use_alt_mach_code);
1754 if (bfd_get_flavour (obfd) == bfd_target_elf_flavour)
1756 non_fatal (_("treating that number as an absolute e_machine value instead"));
1757 elf_elfheader (obfd)->e_machine = use_alt_mach_code;
1759 else
1760 non_fatal (_("ignoring the alternative value"));
1764 return TRUE;
1767 /* Read each archive element in turn from IBFD, copy the
1768 contents to temp file, and keep the temp file handle.
1769 If 'force_output_target' is TRUE then make sure that
1770 all elements in the new archive are of the type
1771 'output_target'. */
1773 static void
1774 copy_archive (bfd *ibfd, bfd *obfd, const char *output_target,
1775 bfd_boolean force_output_target)
1777 struct name_list
1779 struct name_list *next;
1780 const char *name;
1781 bfd *obfd;
1782 } *list, *l;
1783 bfd **ptr = &obfd->archive_head;
1784 bfd *this_element;
1785 char * dir;
1787 /* Make a temp directory to hold the contents. */
1788 dir = make_tempdir (bfd_get_filename (obfd));
1789 if (dir == NULL)
1790 fatal (_("cannot create tempdir for archive copying (error: %s)"),
1791 strerror (errno));
1793 obfd->has_armap = ibfd->has_armap;
1795 list = NULL;
1797 this_element = bfd_openr_next_archived_file (ibfd, NULL);
1799 if (!bfd_set_format (obfd, bfd_get_format (ibfd)))
1800 RETURN_NONFATAL (bfd_get_filename (obfd));
1802 while (!status && this_element != NULL)
1804 char *output_name;
1805 bfd *output_bfd;
1806 bfd *last_element;
1807 struct stat buf;
1808 int stat_status = 0;
1809 bfd_boolean delete = TRUE;
1811 /* Create an output file for this member. */
1812 output_name = concat (dir, "/",
1813 bfd_get_filename (this_element), (char *) 0);
1815 /* If the file already exists, make another temp dir. */
1816 if (stat (output_name, &buf) >= 0)
1818 output_name = make_tempdir (output_name);
1819 if (output_name == NULL)
1820 fatal (_("cannot create tempdir for archive copying (error: %s)"),
1821 strerror (errno));
1823 l = xmalloc (sizeof (struct name_list));
1824 l->name = output_name;
1825 l->next = list;
1826 l->obfd = NULL;
1827 list = l;
1828 output_name = concat (output_name, "/",
1829 bfd_get_filename (this_element), (char *) 0);
1832 if (preserve_dates)
1834 stat_status = bfd_stat_arch_elt (this_element, &buf);
1836 if (stat_status != 0)
1837 non_fatal (_("internal stat error on %s"),
1838 bfd_get_filename (this_element));
1841 l = xmalloc (sizeof (struct name_list));
1842 l->name = output_name;
1843 l->next = list;
1844 l->obfd = NULL;
1845 list = l;
1847 if (bfd_check_format (this_element, bfd_object))
1849 /* PR binutils/3110: Cope with archives
1850 containing multiple target types. */
1851 if (force_output_target)
1852 output_bfd = bfd_openw (output_name, output_target);
1853 else
1854 output_bfd = bfd_openw (output_name, bfd_get_target (this_element));
1856 if (output_bfd == NULL)
1857 RETURN_NONFATAL (output_name);
1859 delete = ! copy_object (this_element, output_bfd);
1861 if (! delete
1862 || bfd_get_arch (this_element) != bfd_arch_unknown)
1864 if (!bfd_close (output_bfd))
1866 bfd_nonfatal (bfd_get_filename (output_bfd));
1867 /* Error in new object file. Don't change archive. */
1868 status = 1;
1871 else
1872 goto copy_unknown_element;
1874 else
1876 non_fatal (_("Unable to recognise the format of the input file `%s'"),
1877 bfd_get_archive_filename (this_element));
1879 output_bfd = bfd_openw (output_name, output_target);
1880 copy_unknown_element:
1881 delete = !copy_unknown_object (this_element, output_bfd);
1882 if (!bfd_close_all_done (output_bfd))
1884 bfd_nonfatal (bfd_get_filename (output_bfd));
1885 /* Error in new object file. Don't change archive. */
1886 status = 1;
1890 if (delete)
1892 unlink (output_name);
1893 status = 1;
1895 else
1897 if (preserve_dates && stat_status == 0)
1898 set_times (output_name, &buf);
1900 /* Open the newly output file and attach to our list. */
1901 output_bfd = bfd_openr (output_name, output_target);
1903 l->obfd = output_bfd;
1905 *ptr = output_bfd;
1906 ptr = &output_bfd->next;
1908 last_element = this_element;
1910 this_element = bfd_openr_next_archived_file (ibfd, last_element);
1912 bfd_close (last_element);
1915 *ptr = NULL;
1917 if (!bfd_close (obfd))
1918 RETURN_NONFATAL (bfd_get_filename (obfd));
1920 if (!bfd_close (ibfd))
1921 RETURN_NONFATAL (bfd_get_filename (ibfd));
1923 /* Delete all the files that we opened. */
1924 for (l = list; l != NULL; l = l->next)
1926 if (l->obfd == NULL)
1927 rmdir (l->name);
1928 else
1930 bfd_close (l->obfd);
1931 unlink (l->name);
1934 rmdir (dir);
1937 /* The top-level control. */
1939 static void
1940 copy_file (const char *input_filename, const char *output_filename,
1941 const char *input_target, const char *output_target)
1943 bfd *ibfd;
1944 char **obj_matching;
1945 char **core_matching;
1947 if (get_file_size (input_filename) < 1)
1949 status = 1;
1950 return;
1953 /* To allow us to do "strip *" without dying on the first
1954 non-object file, failures are nonfatal. */
1955 ibfd = bfd_openr (input_filename, input_target);
1956 if (ibfd == NULL)
1957 RETURN_NONFATAL (input_filename);
1959 if (bfd_check_format (ibfd, bfd_archive))
1961 bfd_boolean force_output_target;
1962 bfd *obfd;
1964 /* bfd_get_target does not return the correct value until
1965 bfd_check_format succeeds. */
1966 if (output_target == NULL)
1968 output_target = bfd_get_target (ibfd);
1969 force_output_target = FALSE;
1971 else
1972 force_output_target = TRUE;
1974 obfd = bfd_openw (output_filename, output_target);
1975 if (obfd == NULL)
1976 RETURN_NONFATAL (output_filename);
1978 copy_archive (ibfd, obfd, output_target, force_output_target);
1980 else if (bfd_check_format_matches (ibfd, bfd_object, &obj_matching))
1982 bfd *obfd;
1983 do_copy:
1985 /* bfd_get_target does not return the correct value until
1986 bfd_check_format succeeds. */
1987 if (output_target == NULL)
1988 output_target = bfd_get_target (ibfd);
1990 obfd = bfd_openw (output_filename, output_target);
1991 if (obfd == NULL)
1992 RETURN_NONFATAL (output_filename);
1994 if (! copy_object (ibfd, obfd))
1995 status = 1;
1997 if (!bfd_close (obfd))
1998 RETURN_NONFATAL (output_filename);
2000 if (!bfd_close (ibfd))
2001 RETURN_NONFATAL (input_filename);
2004 else
2006 bfd_error_type obj_error = bfd_get_error ();
2007 bfd_error_type core_error;
2009 if (bfd_check_format_matches (ibfd, bfd_core, &core_matching))
2011 /* This probably can't happen.. */
2012 if (obj_error == bfd_error_file_ambiguously_recognized)
2013 free (obj_matching);
2014 goto do_copy;
2017 core_error = bfd_get_error ();
2018 /* Report the object error in preference to the core error. */
2019 if (obj_error != core_error)
2020 bfd_set_error (obj_error);
2022 bfd_nonfatal (input_filename);
2024 if (obj_error == bfd_error_file_ambiguously_recognized)
2026 list_matching_formats (obj_matching);
2027 free (obj_matching);
2029 if (core_error == bfd_error_file_ambiguously_recognized)
2031 list_matching_formats (core_matching);
2032 free (core_matching);
2035 status = 1;
2039 /* Add a name to the section renaming list. */
2041 static void
2042 add_section_rename (const char * old_name, const char * new_name,
2043 flagword flags)
2045 section_rename * rename;
2047 /* Check for conflicts first. */
2048 for (rename = section_rename_list; rename != NULL; rename = rename->next)
2049 if (strcmp (rename->old_name, old_name) == 0)
2051 /* Silently ignore duplicate definitions. */
2052 if (strcmp (rename->new_name, new_name) == 0
2053 && rename->flags == flags)
2054 return;
2056 fatal (_("Multiple renames of section %s"), old_name);
2059 rename = xmalloc (sizeof (* rename));
2061 rename->old_name = old_name;
2062 rename->new_name = new_name;
2063 rename->flags = flags;
2064 rename->next = section_rename_list;
2066 section_rename_list = rename;
2069 /* Check the section rename list for a new name of the input section
2070 ISECTION. Return the new name if one is found.
2071 Also set RETURNED_FLAGS to the flags to be used for this section. */
2073 static const char *
2074 find_section_rename (bfd * ibfd ATTRIBUTE_UNUSED, sec_ptr isection,
2075 flagword * returned_flags)
2077 const char * old_name = bfd_section_name (ibfd, isection);
2078 section_rename * rename;
2080 /* Default to using the flags of the input section. */
2081 * returned_flags = bfd_get_section_flags (ibfd, isection);
2083 for (rename = section_rename_list; rename != NULL; rename = rename->next)
2084 if (strcmp (rename->old_name, old_name) == 0)
2086 if (rename->flags != (flagword) -1)
2087 * returned_flags = rename->flags;
2089 return rename->new_name;
2092 return old_name;
2095 /* Once each of the sections is copied, we may still need to do some
2096 finalization work for private section headers. Do that here. */
2098 static void
2099 setup_bfd_headers (bfd *ibfd, bfd *obfd)
2101 const char *err;
2103 /* Allow the BFD backend to copy any private data it understands
2104 from the input section to the output section. */
2105 if (! bfd_copy_private_header_data (ibfd, obfd))
2107 err = _("private header data");
2108 goto loser;
2111 /* All went well. */
2112 return;
2114 loser:
2115 non_fatal (_("%s: error in %s: %s"),
2116 bfd_get_filename (ibfd),
2117 err, bfd_errmsg (bfd_get_error ()));
2118 status = 1;
2121 /* Create a section in OBFD with the same
2122 name and attributes as ISECTION in IBFD. */
2124 static void
2125 setup_section (bfd *ibfd, sec_ptr isection, void *obfdarg)
2127 bfd *obfd = obfdarg;
2128 struct section_list *p;
2129 sec_ptr osection;
2130 bfd_size_type size;
2131 bfd_vma vma;
2132 bfd_vma lma;
2133 flagword flags;
2134 const char *err;
2135 const char * name;
2136 char *prefix = NULL;
2138 if (is_strip_section (ibfd, isection))
2139 return;
2141 p = find_section_list (bfd_section_name (ibfd, isection), FALSE);
2142 if (p != NULL)
2143 p->used = TRUE;
2145 /* Get the, possibly new, name of the output section. */
2146 name = find_section_rename (ibfd, isection, & flags);
2148 /* Prefix sections. */
2149 if ((prefix_alloc_sections_string)
2150 && (bfd_get_section_flags (ibfd, isection) & SEC_ALLOC))
2151 prefix = prefix_alloc_sections_string;
2152 else if (prefix_sections_string)
2153 prefix = prefix_sections_string;
2155 if (prefix)
2157 char *n;
2159 n = xmalloc (strlen (prefix) + strlen (name) + 1);
2160 strcpy (n, prefix);
2161 strcat (n, name);
2162 name = n;
2165 if (p != NULL && p->set_flags)
2166 flags = p->flags | (flags & (SEC_HAS_CONTENTS | SEC_RELOC));
2167 else if (strip_symbols == STRIP_NONDEBUG && (flags & SEC_ALLOC) != 0)
2168 flags &= ~(SEC_HAS_CONTENTS | SEC_LOAD);
2170 osection = bfd_make_section_anyway_with_flags (obfd, name, flags);
2172 if (osection == NULL)
2174 err = _("making");
2175 goto loser;
2178 if (strip_symbols == STRIP_NONDEBUG
2179 && obfd->xvec->flavour == bfd_target_elf_flavour
2180 && (flags & SEC_ALLOC) != 0
2181 && (p == NULL || !p->set_flags))
2182 elf_section_type (osection) = SHT_NOBITS;
2184 size = bfd_section_size (ibfd, isection);
2185 if (copy_byte >= 0)
2186 size = (size + interleave - 1) / interleave;
2187 if (! bfd_set_section_size (obfd, osection, size))
2189 err = _("size");
2190 goto loser;
2193 vma = bfd_section_vma (ibfd, isection);
2194 if (p != NULL && p->change_vma == CHANGE_MODIFY)
2195 vma += p->vma_val;
2196 else if (p != NULL && p->change_vma == CHANGE_SET)
2197 vma = p->vma_val;
2198 else
2199 vma += change_section_address;
2201 if (! bfd_set_section_vma (obfd, osection, vma))
2203 err = _("vma");
2204 goto loser;
2207 lma = isection->lma;
2208 if ((p != NULL) && p->change_lma != CHANGE_IGNORE)
2210 if (p->change_lma == CHANGE_MODIFY)
2211 lma += p->lma_val;
2212 else if (p->change_lma == CHANGE_SET)
2213 lma = p->lma_val;
2214 else
2215 abort ();
2217 else
2218 lma += change_section_address;
2220 osection->lma = lma;
2222 /* FIXME: This is probably not enough. If we change the LMA we
2223 may have to recompute the header for the file as well. */
2224 if (!bfd_set_section_alignment (obfd,
2225 osection,
2226 bfd_section_alignment (ibfd, isection)))
2228 err = _("alignment");
2229 goto loser;
2232 /* Copy merge entity size. */
2233 osection->entsize = isection->entsize;
2235 /* This used to be mangle_section; we do here to avoid using
2236 bfd_get_section_by_name since some formats allow multiple
2237 sections with the same name. */
2238 isection->output_section = osection;
2239 isection->output_offset = 0;
2241 /* Allow the BFD backend to copy any private data it understands
2242 from the input section to the output section. */
2243 if (bfd_get_flavour (ibfd) == bfd_target_elf_flavour
2244 && strip_symbols == STRIP_NONDEBUG)
2245 /* Do not copy the private data when creating an ELF format
2246 debug info file. We do not want the program headers. */
2248 else if (!bfd_copy_private_section_data (ibfd, isection, obfd, osection))
2250 err = _("private data");
2251 goto loser;
2253 else if ((isection->flags & SEC_GROUP) != 0)
2255 asymbol *gsym = group_signature (isection);
2257 if (gsym != NULL)
2258 gsym->flags |= BSF_KEEP;
2261 /* All went well. */
2262 return;
2264 loser:
2265 non_fatal (_("%s: section `%s': error in %s: %s"),
2266 bfd_get_filename (ibfd),
2267 bfd_section_name (ibfd, isection),
2268 err, bfd_errmsg (bfd_get_error ()));
2269 status = 1;
2272 /* Copy the data of input section ISECTION of IBFD
2273 to an output section with the same name in OBFD.
2274 If stripping then don't copy any relocation info. */
2276 static void
2277 copy_section (bfd *ibfd, sec_ptr isection, void *obfdarg)
2279 bfd *obfd = obfdarg;
2280 struct section_list *p;
2281 arelent **relpp;
2282 long relcount;
2283 sec_ptr osection;
2284 bfd_size_type size;
2285 long relsize;
2286 flagword flags;
2288 /* If we have already failed earlier on,
2289 do not keep on generating complaints now. */
2290 if (status != 0)
2291 return;
2293 if (is_strip_section (ibfd, isection))
2294 return;
2296 flags = bfd_get_section_flags (ibfd, isection);
2297 if ((flags & SEC_GROUP) != 0)
2298 return;
2300 osection = isection->output_section;
2301 size = bfd_get_section_size (isection);
2303 if (size == 0 || osection == 0)
2304 return;
2306 p = find_section_list (bfd_get_section_name (ibfd, isection), FALSE);
2308 /* Core files do not need to be relocated. */
2309 if (bfd_get_format (obfd) == bfd_core)
2310 relsize = 0;
2311 else
2313 relsize = bfd_get_reloc_upper_bound (ibfd, isection);
2315 if (relsize < 0)
2317 /* Do not complain if the target does not support relocations. */
2318 if (relsize == -1 && bfd_get_error () == bfd_error_invalid_operation)
2319 relsize = 0;
2320 else
2321 RETURN_NONFATAL (bfd_get_filename (ibfd));
2325 if (relsize == 0)
2326 bfd_set_reloc (obfd, osection, NULL, 0);
2327 else
2329 relpp = xmalloc (relsize);
2330 relcount = bfd_canonicalize_reloc (ibfd, isection, relpp, isympp);
2331 if (relcount < 0)
2332 RETURN_NONFATAL (bfd_get_filename (ibfd));
2334 if (strip_symbols == STRIP_ALL)
2336 /* Remove relocations which are not in
2337 keep_strip_specific_list. */
2338 arelent **temp_relpp;
2339 long temp_relcount = 0;
2340 long i;
2342 temp_relpp = xmalloc (relsize);
2343 for (i = 0; i < relcount; i++)
2344 if (is_specified_symbol (bfd_asymbol_name (*relpp[i]->sym_ptr_ptr),
2345 keep_specific_list))
2346 temp_relpp [temp_relcount++] = relpp [i];
2347 relcount = temp_relcount;
2348 free (relpp);
2349 relpp = temp_relpp;
2352 bfd_set_reloc (obfd, osection, relcount == 0 ? NULL : relpp, relcount);
2353 if (relcount == 0)
2354 free (relpp);
2357 if (bfd_get_section_flags (ibfd, isection) & SEC_HAS_CONTENTS
2358 && bfd_get_section_flags (obfd, osection) & SEC_HAS_CONTENTS)
2360 void *memhunk = xmalloc (size);
2362 if (!bfd_get_section_contents (ibfd, isection, memhunk, 0, size))
2363 RETURN_NONFATAL (bfd_get_filename (ibfd));
2365 if (copy_byte >= 0)
2367 /* Keep only every `copy_byte'th byte in MEMHUNK. */
2368 char *from = (char *) memhunk + copy_byte;
2369 char *to = memhunk;
2370 char *end = (char *) memhunk + size;
2372 for (; from < end; from += interleave)
2373 *to++ = *from;
2375 size = (size + interleave - 1 - copy_byte) / interleave;
2376 osection->lma /= interleave;
2379 if (!bfd_set_section_contents (obfd, osection, memhunk, 0, size))
2380 RETURN_NONFATAL (bfd_get_filename (obfd));
2382 free (memhunk);
2384 else if (p != NULL && p->set_flags && (p->flags & SEC_HAS_CONTENTS) != 0)
2386 void *memhunk = xmalloc (size);
2388 /* We don't permit the user to turn off the SEC_HAS_CONTENTS
2389 flag--they can just remove the section entirely and add it
2390 back again. However, we do permit them to turn on the
2391 SEC_HAS_CONTENTS flag, and take it to mean that the section
2392 contents should be zeroed out. */
2394 memset (memhunk, 0, size);
2395 if (! bfd_set_section_contents (obfd, osection, memhunk, 0, size))
2396 RETURN_NONFATAL (bfd_get_filename (obfd));
2397 free (memhunk);
2401 /* Get all the sections. This is used when --gap-fill or --pad-to is
2402 used. */
2404 static void
2405 get_sections (bfd *obfd ATTRIBUTE_UNUSED, asection *osection, void *secppparg)
2407 asection ***secppp = secppparg;
2409 **secppp = osection;
2410 ++(*secppp);
2413 /* Sort sections by VMA. This is called via qsort, and is used when
2414 --gap-fill or --pad-to is used. We force non loadable or empty
2415 sections to the front, where they are easier to ignore. */
2417 static int
2418 compare_section_lma (const void *arg1, const void *arg2)
2420 const asection *const *sec1 = arg1;
2421 const asection *const *sec2 = arg2;
2422 flagword flags1, flags2;
2424 /* Sort non loadable sections to the front. */
2425 flags1 = (*sec1)->flags;
2426 flags2 = (*sec2)->flags;
2427 if ((flags1 & SEC_HAS_CONTENTS) == 0
2428 || (flags1 & SEC_LOAD) == 0)
2430 if ((flags2 & SEC_HAS_CONTENTS) != 0
2431 && (flags2 & SEC_LOAD) != 0)
2432 return -1;
2434 else
2436 if ((flags2 & SEC_HAS_CONTENTS) == 0
2437 || (flags2 & SEC_LOAD) == 0)
2438 return 1;
2441 /* Sort sections by LMA. */
2442 if ((*sec1)->lma > (*sec2)->lma)
2443 return 1;
2444 else if ((*sec1)->lma < (*sec2)->lma)
2445 return -1;
2447 /* Sort sections with the same LMA by size. */
2448 if (bfd_get_section_size (*sec1) > bfd_get_section_size (*sec2))
2449 return 1;
2450 else if (bfd_get_section_size (*sec1) < bfd_get_section_size (*sec2))
2451 return -1;
2453 return 0;
2456 /* Mark all the symbols which will be used in output relocations with
2457 the BSF_KEEP flag so that those symbols will not be stripped.
2459 Ignore relocations which will not appear in the output file. */
2461 static void
2462 mark_symbols_used_in_relocations (bfd *ibfd, sec_ptr isection, void *symbolsarg)
2464 asymbol **symbols = symbolsarg;
2465 long relsize;
2466 arelent **relpp;
2467 long relcount, i;
2469 /* Ignore an input section with no corresponding output section. */
2470 if (isection->output_section == NULL)
2471 return;
2473 relsize = bfd_get_reloc_upper_bound (ibfd, isection);
2474 if (relsize < 0)
2476 /* Do not complain if the target does not support relocations. */
2477 if (relsize == -1 && bfd_get_error () == bfd_error_invalid_operation)
2478 return;
2479 bfd_fatal (bfd_get_filename (ibfd));
2482 if (relsize == 0)
2483 return;
2485 relpp = xmalloc (relsize);
2486 relcount = bfd_canonicalize_reloc (ibfd, isection, relpp, symbols);
2487 if (relcount < 0)
2488 bfd_fatal (bfd_get_filename (ibfd));
2490 /* Examine each symbol used in a relocation. If it's not one of the
2491 special bfd section symbols, then mark it with BSF_KEEP. */
2492 for (i = 0; i < relcount; i++)
2494 if (*relpp[i]->sym_ptr_ptr != bfd_com_section_ptr->symbol
2495 && *relpp[i]->sym_ptr_ptr != bfd_abs_section_ptr->symbol
2496 && *relpp[i]->sym_ptr_ptr != bfd_und_section_ptr->symbol)
2497 (*relpp[i]->sym_ptr_ptr)->flags |= BSF_KEEP;
2500 if (relpp != NULL)
2501 free (relpp);
2504 /* Write out debugging information. */
2506 static bfd_boolean
2507 write_debugging_info (bfd *obfd, void *dhandle,
2508 long *symcountp ATTRIBUTE_UNUSED,
2509 asymbol ***symppp ATTRIBUTE_UNUSED)
2511 if (bfd_get_flavour (obfd) == bfd_target_ieee_flavour)
2512 return write_ieee_debugging_info (obfd, dhandle);
2514 if (bfd_get_flavour (obfd) == bfd_target_coff_flavour
2515 || bfd_get_flavour (obfd) == bfd_target_elf_flavour)
2517 bfd_byte *syms, *strings;
2518 bfd_size_type symsize, stringsize;
2519 asection *stabsec, *stabstrsec;
2520 flagword flags;
2522 if (! write_stabs_in_sections_debugging_info (obfd, dhandle, &syms,
2523 &symsize, &strings,
2524 &stringsize))
2525 return FALSE;
2527 flags = SEC_HAS_CONTENTS | SEC_READONLY | SEC_DEBUGGING;
2528 stabsec = bfd_make_section_with_flags (obfd, ".stab", flags);
2529 stabstrsec = bfd_make_section_with_flags (obfd, ".stabstr", flags);
2530 if (stabsec == NULL
2531 || stabstrsec == NULL
2532 || ! bfd_set_section_size (obfd, stabsec, symsize)
2533 || ! bfd_set_section_size (obfd, stabstrsec, stringsize)
2534 || ! bfd_set_section_alignment (obfd, stabsec, 2)
2535 || ! bfd_set_section_alignment (obfd, stabstrsec, 0))
2537 non_fatal (_("%s: can't create debugging section: %s"),
2538 bfd_get_filename (obfd),
2539 bfd_errmsg (bfd_get_error ()));
2540 return FALSE;
2543 /* We can get away with setting the section contents now because
2544 the next thing the caller is going to do is copy over the
2545 real sections. We may someday have to split the contents
2546 setting out of this function. */
2547 if (! bfd_set_section_contents (obfd, stabsec, syms, 0, symsize)
2548 || ! bfd_set_section_contents (obfd, stabstrsec, strings, 0,
2549 stringsize))
2551 non_fatal (_("%s: can't set debugging section contents: %s"),
2552 bfd_get_filename (obfd),
2553 bfd_errmsg (bfd_get_error ()));
2554 return FALSE;
2557 return TRUE;
2560 non_fatal (_("%s: don't know how to write debugging information for %s"),
2561 bfd_get_filename (obfd), bfd_get_target (obfd));
2562 return FALSE;
2565 static int
2566 strip_main (int argc, char *argv[])
2568 char *input_target = NULL;
2569 char *output_target = NULL;
2570 bfd_boolean show_version = FALSE;
2571 bfd_boolean formats_info = FALSE;
2572 int c;
2573 int i;
2574 struct section_list *p;
2575 char *output_file = NULL;
2577 while ((c = getopt_long (argc, argv, "I:O:F:K:N:R:o:sSpdgxXHhVvw",
2578 strip_options, (int *) 0)) != EOF)
2580 switch (c)
2582 case 'I':
2583 input_target = optarg;
2584 break;
2585 case 'O':
2586 output_target = optarg;
2587 break;
2588 case 'F':
2589 input_target = output_target = optarg;
2590 break;
2591 case 'R':
2592 p = find_section_list (optarg, TRUE);
2593 p->remove = TRUE;
2594 sections_removed = TRUE;
2595 break;
2596 case 's':
2597 strip_symbols = STRIP_ALL;
2598 break;
2599 case 'S':
2600 case 'g':
2601 case 'd': /* Historic BSD alias for -g. Used by early NetBSD. */
2602 strip_symbols = STRIP_DEBUG;
2603 break;
2604 case OPTION_STRIP_UNNEEDED:
2605 strip_symbols = STRIP_UNNEEDED;
2606 break;
2607 case 'K':
2608 add_specific_symbol (optarg, &keep_specific_list);
2609 break;
2610 case 'N':
2611 add_specific_symbol (optarg, &strip_specific_list);
2612 break;
2613 case 'o':
2614 output_file = optarg;
2615 break;
2616 case 'p':
2617 preserve_dates = TRUE;
2618 break;
2619 case 'x':
2620 discard_locals = LOCALS_ALL;
2621 break;
2622 case 'X':
2623 discard_locals = LOCALS_START_L;
2624 break;
2625 case 'v':
2626 verbose = TRUE;
2627 break;
2628 case 'V':
2629 show_version = TRUE;
2630 break;
2631 case OPTION_FORMATS_INFO:
2632 formats_info = TRUE;
2633 break;
2634 case OPTION_ONLY_KEEP_DEBUG:
2635 strip_symbols = STRIP_NONDEBUG;
2636 break;
2637 case OPTION_KEEP_FILE_SYMBOLS:
2638 keep_file_symbols = 1;
2639 break;
2640 case 0:
2641 /* We've been given a long option. */
2642 break;
2643 case 'w':
2644 wildcard = TRUE;
2645 break;
2646 case 'H':
2647 case 'h':
2648 strip_usage (stdout, 0);
2649 default:
2650 strip_usage (stderr, 1);
2654 if (formats_info)
2656 display_info ();
2657 return 0;
2660 if (show_version)
2661 print_version ("strip");
2663 /* Default is to strip all symbols. */
2664 if (strip_symbols == STRIP_UNDEF
2665 && discard_locals == LOCALS_UNDEF
2666 && strip_specific_list == NULL)
2667 strip_symbols = STRIP_ALL;
2669 if (output_target == NULL)
2670 output_target = input_target;
2672 i = optind;
2673 if (i == argc
2674 || (output_file != NULL && (i + 1) < argc))
2675 strip_usage (stderr, 1);
2677 for (; i < argc; i++)
2679 int hold_status = status;
2680 struct stat statbuf;
2681 char *tmpname;
2683 if (get_file_size (argv[i]) < 1)
2685 status = 1;
2686 continue;
2689 if (preserve_dates)
2690 /* No need to check the return value of stat().
2691 It has already been checked in get_file_size(). */
2692 stat (argv[i], &statbuf);
2694 if (output_file != NULL)
2695 tmpname = output_file;
2696 else
2697 tmpname = make_tempname (argv[i]);
2699 if (tmpname == NULL)
2701 non_fatal (_("could not create temporary file to hold stripped copy of '%s'"),
2702 argv[i]);
2703 status = 1;
2704 continue;
2707 status = 0;
2708 copy_file (argv[i], tmpname, input_target, output_target);
2709 if (status == 0)
2711 if (preserve_dates)
2712 set_times (tmpname, &statbuf);
2713 if (output_file == NULL)
2714 smart_rename (tmpname, argv[i], preserve_dates);
2715 status = hold_status;
2717 else
2718 unlink_if_ordinary (tmpname);
2719 if (output_file == NULL)
2720 free (tmpname);
2723 return status;
2726 static int
2727 copy_main (int argc, char *argv[])
2729 char * binary_architecture = NULL;
2730 char *input_filename = NULL;
2731 char *output_filename = NULL;
2732 char *input_target = NULL;
2733 char *output_target = NULL;
2734 bfd_boolean show_version = FALSE;
2735 bfd_boolean change_warn = TRUE;
2736 bfd_boolean formats_info = FALSE;
2737 int c;
2738 struct section_list *p;
2739 struct stat statbuf;
2741 while ((c = getopt_long (argc, argv, "b:B:i:I:j:K:N:s:O:d:F:L:G:R:SpgxXHhVvW:w",
2742 copy_options, (int *) 0)) != EOF)
2744 switch (c)
2746 case 'b':
2747 copy_byte = atoi (optarg);
2748 if (copy_byte < 0)
2749 fatal (_("byte number must be non-negative"));
2750 break;
2752 case 'B':
2753 binary_architecture = optarg;
2754 break;
2756 case 'i':
2757 interleave = atoi (optarg);
2758 if (interleave < 1)
2759 fatal (_("interleave must be positive"));
2760 break;
2762 case 'I':
2763 case 's': /* "source" - 'I' is preferred */
2764 input_target = optarg;
2765 break;
2767 case 'O':
2768 case 'd': /* "destination" - 'O' is preferred */
2769 output_target = optarg;
2770 break;
2772 case 'F':
2773 input_target = output_target = optarg;
2774 break;
2776 case 'j':
2777 p = find_section_list (optarg, TRUE);
2778 if (p->remove)
2779 fatal (_("%s both copied and removed"), optarg);
2780 p->copy = TRUE;
2781 sections_copied = TRUE;
2782 break;
2784 case 'R':
2785 p = find_section_list (optarg, TRUE);
2786 if (p->copy)
2787 fatal (_("%s both copied and removed"), optarg);
2788 p->remove = TRUE;
2789 sections_removed = TRUE;
2790 break;
2792 case 'S':
2793 strip_symbols = STRIP_ALL;
2794 break;
2796 case 'g':
2797 strip_symbols = STRIP_DEBUG;
2798 break;
2800 case OPTION_STRIP_UNNEEDED:
2801 strip_symbols = STRIP_UNNEEDED;
2802 break;
2804 case OPTION_ONLY_KEEP_DEBUG:
2805 strip_symbols = STRIP_NONDEBUG;
2806 break;
2808 case OPTION_KEEP_FILE_SYMBOLS:
2809 keep_file_symbols = 1;
2810 break;
2812 case OPTION_ADD_GNU_DEBUGLINK:
2813 gnu_debuglink_filename = optarg;
2814 break;
2816 case 'K':
2817 add_specific_symbol (optarg, &keep_specific_list);
2818 break;
2820 case 'N':
2821 add_specific_symbol (optarg, &strip_specific_list);
2822 break;
2824 case OPTION_STRIP_UNNEEDED_SYMBOL:
2825 add_specific_symbol (optarg, &strip_unneeded_list);
2826 break;
2828 case 'L':
2829 add_specific_symbol (optarg, &localize_specific_list);
2830 break;
2832 case OPTION_GLOBALIZE_SYMBOL:
2833 add_specific_symbol (optarg, &globalize_specific_list);
2834 break;
2836 case 'G':
2837 add_specific_symbol (optarg, &keepglobal_specific_list);
2838 break;
2840 case 'W':
2841 add_specific_symbol (optarg, &weaken_specific_list);
2842 break;
2844 case 'p':
2845 preserve_dates = TRUE;
2846 break;
2848 case 'w':
2849 wildcard = TRUE;
2850 break;
2852 case 'x':
2853 discard_locals = LOCALS_ALL;
2854 break;
2856 case 'X':
2857 discard_locals = LOCALS_START_L;
2858 break;
2860 case 'v':
2861 verbose = TRUE;
2862 break;
2864 case 'V':
2865 show_version = TRUE;
2866 break;
2868 case OPTION_FORMATS_INFO:
2869 formats_info = TRUE;
2870 break;
2872 case OPTION_WEAKEN:
2873 weaken = TRUE;
2874 break;
2876 case OPTION_ADD_SECTION:
2878 const char *s;
2879 off_t size;
2880 struct section_add *pa;
2881 int len;
2882 char *name;
2883 FILE *f;
2885 s = strchr (optarg, '=');
2887 if (s == NULL)
2888 fatal (_("bad format for %s"), "--add-section");
2890 size = get_file_size (s + 1);
2891 if (size < 1)
2893 status = 1;
2894 break;
2897 pa = xmalloc (sizeof (struct section_add));
2899 len = s - optarg;
2900 name = xmalloc (len + 1);
2901 strncpy (name, optarg, len);
2902 name[len] = '\0';
2903 pa->name = name;
2905 pa->filename = s + 1;
2906 pa->size = size;
2907 pa->contents = xmalloc (size);
2909 f = fopen (pa->filename, FOPEN_RB);
2911 if (f == NULL)
2912 fatal (_("cannot open: %s: %s"),
2913 pa->filename, strerror (errno));
2915 if (fread (pa->contents, 1, pa->size, f) == 0
2916 || ferror (f))
2917 fatal (_("%s: fread failed"), pa->filename);
2919 fclose (f);
2921 pa->next = add_sections;
2922 add_sections = pa;
2924 break;
2926 case OPTION_CHANGE_START:
2927 change_start = parse_vma (optarg, "--change-start");
2928 break;
2930 case OPTION_CHANGE_SECTION_ADDRESS:
2931 case OPTION_CHANGE_SECTION_LMA:
2932 case OPTION_CHANGE_SECTION_VMA:
2934 const char *s;
2935 int len;
2936 char *name;
2937 char *option = NULL;
2938 bfd_vma val;
2939 enum change_action what = CHANGE_IGNORE;
2941 switch (c)
2943 case OPTION_CHANGE_SECTION_ADDRESS:
2944 option = "--change-section-address";
2945 break;
2946 case OPTION_CHANGE_SECTION_LMA:
2947 option = "--change-section-lma";
2948 break;
2949 case OPTION_CHANGE_SECTION_VMA:
2950 option = "--change-section-vma";
2951 break;
2954 s = strchr (optarg, '=');
2955 if (s == NULL)
2957 s = strchr (optarg, '+');
2958 if (s == NULL)
2960 s = strchr (optarg, '-');
2961 if (s == NULL)
2962 fatal (_("bad format for %s"), option);
2966 len = s - optarg;
2967 name = xmalloc (len + 1);
2968 strncpy (name, optarg, len);
2969 name[len] = '\0';
2971 p = find_section_list (name, TRUE);
2973 val = parse_vma (s + 1, option);
2975 switch (*s)
2977 case '=': what = CHANGE_SET; break;
2978 case '-': val = - val; /* Drop through. */
2979 case '+': what = CHANGE_MODIFY; break;
2982 switch (c)
2984 case OPTION_CHANGE_SECTION_ADDRESS:
2985 p->change_vma = what;
2986 p->vma_val = val;
2987 /* Drop through. */
2989 case OPTION_CHANGE_SECTION_LMA:
2990 p->change_lma = what;
2991 p->lma_val = val;
2992 break;
2994 case OPTION_CHANGE_SECTION_VMA:
2995 p->change_vma = what;
2996 p->vma_val = val;
2997 break;
3000 break;
3002 case OPTION_CHANGE_ADDRESSES:
3003 change_section_address = parse_vma (optarg, "--change-addresses");
3004 change_start = change_section_address;
3005 break;
3007 case OPTION_CHANGE_WARNINGS:
3008 change_warn = TRUE;
3009 break;
3011 case OPTION_CHANGE_LEADING_CHAR:
3012 change_leading_char = TRUE;
3013 break;
3015 case OPTION_DEBUGGING:
3016 convert_debugging = TRUE;
3017 break;
3019 case OPTION_GAP_FILL:
3021 bfd_vma gap_fill_vma;
3023 gap_fill_vma = parse_vma (optarg, "--gap-fill");
3024 gap_fill = (bfd_byte) gap_fill_vma;
3025 if ((bfd_vma) gap_fill != gap_fill_vma)
3027 char buff[20];
3029 sprintf_vma (buff, gap_fill_vma);
3031 non_fatal (_("Warning: truncating gap-fill from 0x%s to 0x%x"),
3032 buff, gap_fill);
3034 gap_fill_set = TRUE;
3036 break;
3038 case OPTION_NO_CHANGE_WARNINGS:
3039 change_warn = FALSE;
3040 break;
3042 case OPTION_PAD_TO:
3043 pad_to = parse_vma (optarg, "--pad-to");
3044 pad_to_set = TRUE;
3045 break;
3047 case OPTION_REMOVE_LEADING_CHAR:
3048 remove_leading_char = TRUE;
3049 break;
3051 case OPTION_REDEFINE_SYM:
3053 /* Push this redefinition onto redefine_symbol_list. */
3055 int len;
3056 const char *s;
3057 const char *nextarg;
3058 char *source, *target;
3060 s = strchr (optarg, '=');
3061 if (s == NULL)
3062 fatal (_("bad format for %s"), "--redefine-sym");
3064 len = s - optarg;
3065 source = xmalloc (len + 1);
3066 strncpy (source, optarg, len);
3067 source[len] = '\0';
3069 nextarg = s + 1;
3070 len = strlen (nextarg);
3071 target = xmalloc (len + 1);
3072 strcpy (target, nextarg);
3074 redefine_list_append ("--redefine-sym", source, target);
3076 free (source);
3077 free (target);
3079 break;
3081 case OPTION_REDEFINE_SYMS:
3082 add_redefine_syms_file (optarg);
3083 break;
3085 case OPTION_SET_SECTION_FLAGS:
3087 const char *s;
3088 int len;
3089 char *name;
3091 s = strchr (optarg, '=');
3092 if (s == NULL)
3093 fatal (_("bad format for %s"), "--set-section-flags");
3095 len = s - optarg;
3096 name = xmalloc (len + 1);
3097 strncpy (name, optarg, len);
3098 name[len] = '\0';
3100 p = find_section_list (name, TRUE);
3102 p->set_flags = TRUE;
3103 p->flags = parse_flags (s + 1);
3105 break;
3107 case OPTION_RENAME_SECTION:
3109 flagword flags;
3110 const char *eq, *fl;
3111 char *old_name;
3112 char *new_name;
3113 unsigned int len;
3115 eq = strchr (optarg, '=');
3116 if (eq == NULL)
3117 fatal (_("bad format for %s"), "--rename-section");
3119 len = eq - optarg;
3120 if (len == 0)
3121 fatal (_("bad format for %s"), "--rename-section");
3123 old_name = xmalloc (len + 1);
3124 strncpy (old_name, optarg, len);
3125 old_name[len] = 0;
3127 eq++;
3128 fl = strchr (eq, ',');
3129 if (fl)
3131 flags = parse_flags (fl + 1);
3132 len = fl - eq;
3134 else
3136 flags = -1;
3137 len = strlen (eq);
3140 if (len == 0)
3141 fatal (_("bad format for %s"), "--rename-section");
3143 new_name = xmalloc (len + 1);
3144 strncpy (new_name, eq, len);
3145 new_name[len] = 0;
3147 add_section_rename (old_name, new_name, flags);
3149 break;
3151 case OPTION_SET_START:
3152 set_start = parse_vma (optarg, "--set-start");
3153 set_start_set = TRUE;
3154 break;
3156 case OPTION_SREC_LEN:
3157 Chunk = parse_vma (optarg, "--srec-len");
3158 break;
3160 case OPTION_SREC_FORCES3:
3161 S3Forced = TRUE;
3162 break;
3164 case OPTION_STRIP_SYMBOLS:
3165 add_specific_symbols (optarg, &strip_specific_list);
3166 break;
3168 case OPTION_STRIP_UNNEEDED_SYMBOLS:
3169 add_specific_symbols (optarg, &strip_unneeded_list);
3170 break;
3172 case OPTION_KEEP_SYMBOLS:
3173 add_specific_symbols (optarg, &keep_specific_list);
3174 break;
3176 case OPTION_LOCALIZE_HIDDEN:
3177 localize_hidden = TRUE;
3178 break;
3180 case OPTION_LOCALIZE_SYMBOLS:
3181 add_specific_symbols (optarg, &localize_specific_list);
3182 break;
3184 case OPTION_GLOBALIZE_SYMBOLS:
3185 add_specific_symbols (optarg, &globalize_specific_list);
3186 break;
3188 case OPTION_KEEPGLOBAL_SYMBOLS:
3189 add_specific_symbols (optarg, &keepglobal_specific_list);
3190 break;
3192 case OPTION_WEAKEN_SYMBOLS:
3193 add_specific_symbols (optarg, &weaken_specific_list);
3194 break;
3196 case OPTION_ALT_MACH_CODE:
3197 use_alt_mach_code = strtoul (optarg, NULL, 0);
3198 if (use_alt_mach_code == 0)
3199 fatal (_("unable to parse alternative machine code"));
3200 break;
3202 case OPTION_PREFIX_SYMBOLS:
3203 prefix_symbols_string = optarg;
3204 break;
3206 case OPTION_PREFIX_SECTIONS:
3207 prefix_sections_string = optarg;
3208 break;
3210 case OPTION_PREFIX_ALLOC_SECTIONS:
3211 prefix_alloc_sections_string = optarg;
3212 break;
3214 case OPTION_READONLY_TEXT:
3215 bfd_flags_to_set |= WP_TEXT;
3216 bfd_flags_to_clear &= ~WP_TEXT;
3217 break;
3219 case OPTION_WRITABLE_TEXT:
3220 bfd_flags_to_clear |= WP_TEXT;
3221 bfd_flags_to_set &= ~WP_TEXT;
3222 break;
3224 case OPTION_PURE:
3225 bfd_flags_to_set |= D_PAGED;
3226 bfd_flags_to_clear &= ~D_PAGED;
3227 break;
3229 case OPTION_IMPURE:
3230 bfd_flags_to_clear |= D_PAGED;
3231 bfd_flags_to_set &= ~D_PAGED;
3232 break;
3234 case 0:
3235 /* We've been given a long option. */
3236 break;
3238 case 'H':
3239 case 'h':
3240 copy_usage (stdout, 0);
3242 default:
3243 copy_usage (stderr, 1);
3247 if (formats_info)
3249 display_info ();
3250 return 0;
3253 if (show_version)
3254 print_version ("objcopy");
3256 if (copy_byte >= interleave)
3257 fatal (_("byte number must be less than interleave"));
3259 if (optind == argc || optind + 2 < argc)
3260 copy_usage (stderr, 1);
3262 input_filename = argv[optind];
3263 if (optind + 1 < argc)
3264 output_filename = argv[optind + 1];
3266 /* Default is to strip no symbols. */
3267 if (strip_symbols == STRIP_UNDEF && discard_locals == LOCALS_UNDEF)
3268 strip_symbols = STRIP_NONE;
3270 if (output_target == NULL)
3271 output_target = input_target;
3273 if (binary_architecture != NULL)
3275 if (input_target && strcmp (input_target, "binary") == 0)
3277 const bfd_arch_info_type * temp_arch_info;
3279 temp_arch_info = bfd_scan_arch (binary_architecture);
3281 if (temp_arch_info != NULL)
3283 bfd_external_binary_architecture = temp_arch_info->arch;
3284 bfd_external_machine = temp_arch_info->mach;
3286 else
3287 fatal (_("architecture %s unknown"), binary_architecture);
3289 else
3291 non_fatal (_("Warning: input target 'binary' required for binary architecture parameter."));
3292 non_fatal (_(" Argument %s ignored"), binary_architecture);
3296 if (preserve_dates)
3297 if (stat (input_filename, & statbuf) < 0)
3298 fatal (_("warning: could not locate '%s'. System error message: %s"),
3299 input_filename, strerror (errno));
3301 /* If there is no destination file, or the source and destination files
3302 are the same, then create a temp and rename the result into the input. */
3303 if (output_filename == NULL || strcmp (input_filename, output_filename) == 0)
3305 char *tmpname = make_tempname (input_filename);
3307 if (tmpname == NULL)
3308 fatal (_("warning: could not create temporary file whilst copying '%s', (error: %s)"),
3309 input_filename, strerror (errno));
3311 copy_file (input_filename, tmpname, input_target, output_target);
3312 if (status == 0)
3314 if (preserve_dates)
3315 set_times (tmpname, &statbuf);
3316 smart_rename (tmpname, input_filename, preserve_dates);
3318 else
3319 unlink (tmpname);
3321 else
3323 copy_file (input_filename, output_filename, input_target, output_target);
3325 if (status == 0 && preserve_dates)
3326 set_times (output_filename, &statbuf);
3327 else if (status != 0)
3328 unlink_if_ordinary (output_filename);
3331 if (change_warn)
3333 for (p = change_sections; p != NULL; p = p->next)
3335 if (! p->used)
3337 if (p->change_vma != CHANGE_IGNORE)
3339 char buff [20];
3341 sprintf_vma (buff, p->vma_val);
3343 /* xgettext:c-format */
3344 non_fatal (_("%s %s%c0x%s never used"),
3345 "--change-section-vma",
3346 p->name,
3347 p->change_vma == CHANGE_SET ? '=' : '+',
3348 buff);
3351 if (p->change_lma != CHANGE_IGNORE)
3353 char buff [20];
3355 sprintf_vma (buff, p->lma_val);
3357 /* xgettext:c-format */
3358 non_fatal (_("%s %s%c0x%s never used"),
3359 "--change-section-lma",
3360 p->name,
3361 p->change_lma == CHANGE_SET ? '=' : '+',
3362 buff);
3368 return 0;
3372 main (int argc, char *argv[])
3374 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
3375 setlocale (LC_MESSAGES, "");
3376 #endif
3377 #if defined (HAVE_SETLOCALE)
3378 setlocale (LC_CTYPE, "");
3379 #endif
3380 bindtextdomain (PACKAGE, LOCALEDIR);
3381 textdomain (PACKAGE);
3383 program_name = argv[0];
3384 xmalloc_set_program_name (program_name);
3386 START_PROGRESS (program_name, 0);
3388 expandargv (&argc, &argv);
3390 strip_symbols = STRIP_UNDEF;
3391 discard_locals = LOCALS_UNDEF;
3393 bfd_init ();
3394 set_default_bfd_target ();
3396 if (is_strip < 0)
3398 int i = strlen (program_name);
3399 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
3400 /* Drop the .exe suffix, if any. */
3401 if (i > 4 && FILENAME_CMP (program_name + i - 4, ".exe") == 0)
3403 i -= 4;
3404 program_name[i] = '\0';
3406 #endif
3407 is_strip = (i >= 5 && FILENAME_CMP (program_name + i - 5, "strip") == 0);
3410 if (is_strip)
3411 strip_main (argc, argv);
3412 else
3413 copy_main (argc, argv);
3415 END_PROGRESS (program_name);
3417 return status;