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
27 #include "libiberty.h"
29 #include "filenames.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
46 /* A list to support redefine_sym. */
51 struct redefine_node *next;
54 typedef struct section_rename
56 const char * old_name;
57 const char * new_name;
59 struct section_rename * next;
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. */
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;
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. */
110 /* Structure used to hold lists of sections and actions to take. */
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. */
160 /* Next section to add. */
161 struct section_add *next;
162 /* Name of section to add. */
164 /* Name of file holding section contents. */
165 const char *filename;
168 /* Contents of file. */
170 /* BFD section, after it has been added. */
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,
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,
225 OPTION_CHANGE_SECTION_ADDRESS,
226 OPTION_CHANGE_SECTION_LMA,
227 OPTION_CHANGE_SECTION_VMA,
228 OPTION_CHANGE_WARNINGS,
231 OPTION_NO_CHANGE_WARNINGS,
233 OPTION_REMOVE_LEADING_CHAR,
234 OPTION_SET_SECTION_FLAGS,
236 OPTION_STRIP_UNNEEDED,
239 OPTION_REDEFINE_SYMS,
242 OPTION_STRIP_SYMBOLS,
243 OPTION_STRIP_UNNEEDED_SYMBOL,
244 OPTION_STRIP_UNNEEDED_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,
258 OPTION_ADD_GNU_DEBUGLINK,
259 OPTION_ONLY_KEEP_DEBUG,
260 OPTION_KEEP_FILE_SYMBOLS,
261 OPTION_READONLY_TEXT,
262 OPTION_WRITABLE_TEXT,
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}
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. */
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
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 *);
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\
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\
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\
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\
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\
498 list_supported_targets (program_name, stream);
499 if (exit_status == 0)
500 fprintf (stream, _("Report bugs to %s\n"), REPORT_BUGS_TO);
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\
533 list_supported_targets (program_name, stream);
534 if (exit_status == 0)
535 fprintf (stream, _("Report bugs to %s\n"), REPORT_BUGS_TO);
539 /* Parse section flags into a flagword, with a fatal error if the
540 string can't be parsed. */
543 parse_flags (const char *s)
553 snext = strchr (s, ',');
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);
580 copy = xmalloc (len + 1);
581 strncpy (copy, s, len);
583 non_fatal (_("unrecognized section flag `%s'"), copy);
584 fatal (_("supported flags: %s"),
585 "alloc, load, noload, readonly, debug, code, data, rom, share, contents");
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)
609 p = xmalloc (sizeof (struct section_list));
614 p->change_vma = CHANGE_IGNORE;
615 p->change_lma = CHANGE_IGNORE;
618 p->set_flags = FALSE;
621 p->next = change_sections;
627 /* Add a symbol to strip_specific_list. */
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;
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')
646 add_specific_symbols (const char *filename, struct symlist **list)
652 unsigned int line_count;
654 size = get_file_size (filename);
661 buffer = xmalloc (size + 2);
662 f = fopen (filename, FOPEN_RT);
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);
670 buffer [size] = '\n';
671 buffer [size + 1] = '\0';
675 for (line = buffer; * line != '\0'; line ++)
680 int finished = FALSE;
682 for (eol = line;; eol ++)
688 /* Cope with \n\r. */
696 /* Cope with \r\n. */
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. */
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));
732 if (! IS_LINE_TERMINATOR (* name_end))
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);
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. */
756 /* See whether a symbol should be stripped or kept based on
757 strip_specific_list and keep_symbols. */
760 is_specified_symbol (const char *name, struct symlist *list)
762 struct symlist *tmp_list;
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))
774 if (fnmatch (tmp_list->name + 1, name, 0))
780 for (tmp_list = list; tmp_list; tmp_list = tmp_list->next)
781 if (strcmp (name, tmp_list->name) == 0)
788 /* Return a pointer to the symbol used as a signature for GROUP. */
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)
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];
812 /* See if a section is being removed. */
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)
825 if (sections_copied && (p == NULL || ! p->copy))
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)
838 if (strip_symbols == STRIP_NONDEBUG)
842 if ((bfd_get_section_flags (abfd, sec) & SEC_GROUP) != 0)
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)
854 If we are going to strip the group signature symbol, then
855 strip the group section too. */
856 gsym = group_signature (sec);
861 if ((strip_symbols == STRIP_ALL
862 && !is_specified_symbol (gname, keep_specific_list))
863 || is_specified_symbol (gname, strip_specific_list))
870 /* Return true if SYM is a hidden symbol. */
873 is_hidden_symbol (asymbol *sym)
875 elf_symbol_type *elf_sym;
877 elf_sym = elf_symbol_from (sym->the_bfd, sym);
879 switch (ELF_ST_VISIBILITY (elf_sym->internal_elf_sym.st_other))
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. */
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))
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);
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;
923 /* Check if we will remove the current leading character. */
925 (name[0] == bfd_get_symbol_leading_char (abfd))
926 && (change_leading_char
927 || (remove_leading_char
928 && ((flags & (BSF_GLOBAL | BSF_WEAK)) != 0
930 || bfd_is_com_section (bfd_get_section (sym)))));
932 /* Check if we will add a new leading character. */
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)
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);
969 bfd_asymbol_name (sym) = n;
973 if (strip_symbols == STRIP_ALL)
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
980 else if (relocatable /* Relocatable file. */
981 && (flags & (BSF_GLOBAL | BSF_WEAK)) != 0)
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
989 else if ((flags & BSF_GLOBAL) != 0 /* Global symbol. */
990 || (flags & BSF_WEAK) != 0
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. */
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))
1011 && !(flags & BSF_KEEP)
1012 && is_specified_symbol (name, strip_unneeded_list))
1015 && ((keep_file_symbols && (flags & BSF_FILE))
1016 || is_specified_symbol (name, keep_specific_list)))
1018 if (keep && is_strip_section (abfd, bfd_get_section (sym)))
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;
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;
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;
1058 /* Find the redefined name of symbol SOURCE. */
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;
1072 /* Add a node to a symbol redefine list. */
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\""),
1087 if (strcmp (target, list->target) == 0)
1088 fatal (_("%s: Symbol \"%s\" is target of more than one redefinition"),
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;
1101 /* Handle the --redefine-syms option. Read lines containing "old new"
1102 from the file, and add them to the symbol redefine list. */
1105 add_redefine_syms_file (const char *filename)
1114 file = fopen (filename, "r");
1116 fatal (_("couldn't open symbol redefinition file %s (error: %s)"),
1117 filename, strerror (errno));
1120 buf = xmalloc (bufsize);
1128 /* Collect the input symbol name. */
1129 while (! IS_WHITESPACE (c) && ! IS_LINE_TERMINATOR (c) && c != EOF)
1137 buf = xrealloc (buf, bufsize);
1145 /* Eat white space between the symbol names. */
1146 while (IS_WHITESPACE (c))
1148 if (c == '#' || IS_LINE_TERMINATOR (c))
1153 /* Collect the output symbol name. */
1155 while (! IS_WHITESPACE (c) && ! IS_LINE_TERMINATOR (c) && c != EOF)
1163 buf = xrealloc (buf, bufsize);
1171 /* Eat white space at end of line. */
1172 while (! IS_LINE_TERMINATOR(c) && c != EOF && IS_WHITESPACE (c))
1177 if ((c == '\r' && (c = getc (file)) == '\n')
1178 || c == '\n' || c == EOF)
1181 /* Append the redefinition to the list. */
1183 redefine_list_append (filename, &buf[0], &buf[outsym_off]);
1194 fatal (_("%s:%d: garbage found at end of line"), filename, lineno);
1196 if (len != 0 && (outsym_off == 0 || outsym_off == len))
1197 fatal (_("%s:%d: missing new symbol name"), filename, lineno);
1200 /* Eat the rest of the line and finish it. */
1201 while (c != '\n' && c != EOF)
1207 fatal (_("%s:%d: premature end of file"), filename, lineno);
1212 /* Copy unkown object file IBFD onto OBFD.
1213 Returns TRUE upon success, FALSE otherwise. */
1216 copy_unknown_object (bfd *ibfd, bfd *obfd)
1224 if (bfd_stat_arch_elt (ibfd, &buf) != 0)
1226 bfd_nonfatal (bfd_get_archive_filename (ibfd));
1233 non_fatal (_("stat returns negative size for `%s'"),
1234 bfd_get_archive_filename (ibfd));
1238 if (bfd_seek (ibfd, (file_ptr) 0, SEEK_SET) != 0)
1240 bfd_nonfatal (bfd_get_archive_filename (ibfd));
1245 printf (_("copy from `%s' [unknown] to `%s' [unknown]\n"),
1246 bfd_get_archive_filename (ibfd), bfd_get_filename (obfd));
1248 cbuf = xmalloc (BUFSIZE);
1250 while (ncopied < size)
1252 tocopy = size - ncopied;
1253 if (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));
1264 if (bfd_bwrite (cbuf, (bfd_size_type) tocopy, obfd)
1265 != (bfd_size_type) tocopy)
1267 bfd_nonfatal (bfd_get_filename (obfd));
1275 chmod (bfd_get_filename (obfd), buf.st_mode);
1280 /* Copy object file IBFD onto OBFD.
1281 Returns TRUE upon success, FALSE otherwise. */
1284 copy_object (bfd *ibfd, bfd *obfd)
1288 asection **osections = NULL;
1289 asection *gnu_debuglink_section = NULL;
1290 bfd_size_type *gaps = NULL;
1291 bfd_size_type max_gap = 0;
1294 enum bfd_architecture iarch;
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));
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));
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)
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));
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));
1349 non_fatal (_("Warning: Output file cannot represent architecture `%s'"),
1350 bfd_printable_arch_mach (bfd_get_arch (ibfd),
1351 bfd_get_mach (ibfd)));
1355 if (!bfd_set_format (obfd, bfd_get_format (ibfd)))
1357 bfd_nonfatal (bfd_get_archive_filename (ibfd));
1364 if (osympp != isympp)
1370 symsize = bfd_get_symtab_upper_bound (ibfd);
1373 bfd_nonfatal (bfd_get_archive_filename (ibfd));
1377 osympp = isympp = xmalloc (symsize);
1378 symcount = bfd_canonicalize_symtab (ibfd, isympp);
1381 bfd_nonfatal (bfd_get_filename (ibfd));
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)
1400 pset = find_section_list (padd->name, FALSE);
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);
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 ()));
1426 if (! bfd_set_section_size (obfd, padd->section, padd->size))
1428 bfd_nonfatal (bfd_get_filename (obfd));
1434 if (pset->change_vma != CHANGE_IGNORE)
1435 if (! bfd_set_section_vma (obfd, padd->section,
1438 bfd_nonfatal (bfd_get_filename (obfd));
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));
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);
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;
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
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;
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. */
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!"));
1519 if (gap_fill_set || pad_to_set)
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 *));
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));
1542 for (i = 0; i < c - 1; i++)
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)
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 ()));
1567 gaps[i] = gap_stop - gap_start;
1568 if (max_gap < gap_stop - gap_start)
1569 max_gap = gap_stop - gap_start;
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],
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 ()));
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. */
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
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
1622 || convert_debugging
1623 || change_leading_char
1624 || remove_leading_char
1625 || redefine_sym_list
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
1636 if (strip_symbols != STRIP_ALL)
1637 bfd_map_over_sections (ibfd,
1638 mark_symbols_used_in_relocations,
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))
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,
1667 bfd_nonfatal (bfd_get_filename (obfd));
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);
1683 if (gap_fill_set || pad_to_set)
1688 /* Fill in the gaps. */
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++)
1703 off = bfd_section_size (obfd, osections[i]) - left;
1714 if (! bfd_set_section_contents (obfd, osections[i], buf,
1717 bfd_nonfatal (bfd_get_filename (obfd));
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 ()));
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"),
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;
1760 non_fatal (_("ignoring the alternative value"));
1768 #if defined (_WIN32) && !defined (__CYGWIN32__)
1769 #define MKDIR(DIR, MODE) mkdir (DIR)
1771 #define MKDIR(DIR, MODE) mkdir (DIR, MODE)
1774 /* Read each archive element in turn from IBFD, copy the
1775 contents to temp file, and keep the temp file handle.
1776 If 'force_output_target' is TRUE then make sure that
1777 all elements in the new archive are of the type
1781 copy_archive (bfd *ibfd, bfd *obfd, const char *output_target,
1782 bfd_boolean force_output_target)
1786 struct name_list *next;
1790 bfd **ptr = &obfd->archive_head;
1792 char *dir = make_tempname (bfd_get_filename (obfd));
1794 /* Make a temp directory to hold the contents. */
1795 if (MKDIR (dir, 0700) != 0)
1796 fatal (_("cannot mkdir %s for archive copying (error: %s)"),
1797 dir, strerror (errno));
1799 obfd->has_armap = ibfd->has_armap;
1803 this_element = bfd_openr_next_archived_file (ibfd, NULL);
1805 if (!bfd_set_format (obfd, bfd_get_format (ibfd)))
1806 RETURN_NONFATAL (bfd_get_filename (obfd));
1808 while (!status && this_element != NULL)
1814 int stat_status = 0;
1815 bfd_boolean delete = TRUE;
1817 /* Create an output file for this member. */
1818 output_name = concat (dir, "/",
1819 bfd_get_filename (this_element), (char *) 0);
1821 /* If the file already exists, make another temp dir. */
1822 if (stat (output_name, &buf) >= 0)
1824 output_name = make_tempname (output_name);
1825 if (MKDIR (output_name, 0700) != 0)
1826 fatal (_("cannot mkdir %s for archive copying (error: %s)"),
1827 output_name, strerror (errno));
1829 l = xmalloc (sizeof (struct name_list));
1830 l->name = output_name;
1834 output_name = concat (output_name, "/",
1835 bfd_get_filename (this_element), (char *) 0);
1840 stat_status = bfd_stat_arch_elt (this_element, &buf);
1842 if (stat_status != 0)
1843 non_fatal (_("internal stat error on %s"),
1844 bfd_get_filename (this_element));
1847 l = xmalloc (sizeof (struct name_list));
1848 l->name = output_name;
1853 if (bfd_check_format (this_element, bfd_object))
1855 /* PR binutils/3110: Cope with archives
1856 containing multiple target types. */
1857 if (force_output_target)
1858 output_bfd = bfd_openw (output_name, output_target);
1860 output_bfd = bfd_openw (output_name, bfd_get_target (this_element));
1862 if (output_bfd == NULL)
1863 RETURN_NONFATAL (output_name);
1865 delete = ! copy_object (this_element, output_bfd);
1868 || bfd_get_arch (this_element) != bfd_arch_unknown)
1870 if (!bfd_close (output_bfd))
1872 bfd_nonfatal (bfd_get_filename (output_bfd));
1873 /* Error in new object file. Don't change archive. */
1878 goto copy_unknown_element;
1882 non_fatal (_("Unable to recognise the format of the input file `%s'"),
1883 bfd_get_archive_filename (this_element));
1885 output_bfd = bfd_openw (output_name, output_target);
1886 copy_unknown_element:
1887 delete = !copy_unknown_object (this_element, output_bfd);
1888 if (!bfd_close_all_done (output_bfd))
1890 bfd_nonfatal (bfd_get_filename (output_bfd));
1891 /* Error in new object file. Don't change archive. */
1898 unlink (output_name);
1903 if (preserve_dates && stat_status == 0)
1904 set_times (output_name, &buf);
1906 /* Open the newly output file and attach to our list. */
1907 output_bfd = bfd_openr (output_name, output_target);
1909 l->obfd = output_bfd;
1912 ptr = &output_bfd->next;
1914 last_element = this_element;
1916 this_element = bfd_openr_next_archived_file (ibfd, last_element);
1918 bfd_close (last_element);
1923 if (!bfd_close (obfd))
1924 RETURN_NONFATAL (bfd_get_filename (obfd));
1926 if (!bfd_close (ibfd))
1927 RETURN_NONFATAL (bfd_get_filename (ibfd));
1929 /* Delete all the files that we opened. */
1930 for (l = list; l != NULL; l = l->next)
1932 if (l->obfd == NULL)
1936 bfd_close (l->obfd);
1943 /* The top-level control. */
1946 copy_file (const char *input_filename, const char *output_filename,
1947 const char *input_target, const char *output_target)
1950 char **obj_matching;
1951 char **core_matching;
1953 if (get_file_size (input_filename) < 1)
1959 /* To allow us to do "strip *" without dying on the first
1960 non-object file, failures are nonfatal. */
1961 ibfd = bfd_openr (input_filename, input_target);
1963 RETURN_NONFATAL (input_filename);
1965 if (bfd_check_format (ibfd, bfd_archive))
1967 bfd_boolean force_output_target;
1970 /* bfd_get_target does not return the correct value until
1971 bfd_check_format succeeds. */
1972 if (output_target == NULL)
1974 output_target = bfd_get_target (ibfd);
1975 force_output_target = FALSE;
1978 force_output_target = TRUE;
1980 obfd = bfd_openw (output_filename, output_target);
1982 RETURN_NONFATAL (output_filename);
1984 copy_archive (ibfd, obfd, output_target, force_output_target);
1986 else if (bfd_check_format_matches (ibfd, bfd_object, &obj_matching))
1991 /* bfd_get_target does not return the correct value until
1992 bfd_check_format succeeds. */
1993 if (output_target == NULL)
1994 output_target = bfd_get_target (ibfd);
1996 obfd = bfd_openw (output_filename, output_target);
1998 RETURN_NONFATAL (output_filename);
2000 if (! copy_object (ibfd, obfd))
2003 if (!bfd_close (obfd))
2004 RETURN_NONFATAL (output_filename);
2006 if (!bfd_close (ibfd))
2007 RETURN_NONFATAL (input_filename);
2012 bfd_error_type obj_error = bfd_get_error ();
2013 bfd_error_type core_error;
2015 if (bfd_check_format_matches (ibfd, bfd_core, &core_matching))
2017 /* This probably can't happen.. */
2018 if (obj_error == bfd_error_file_ambiguously_recognized)
2019 free (obj_matching);
2023 core_error = bfd_get_error ();
2024 /* Report the object error in preference to the core error. */
2025 if (obj_error != core_error)
2026 bfd_set_error (obj_error);
2028 bfd_nonfatal (input_filename);
2030 if (obj_error == bfd_error_file_ambiguously_recognized)
2032 list_matching_formats (obj_matching);
2033 free (obj_matching);
2035 if (core_error == bfd_error_file_ambiguously_recognized)
2037 list_matching_formats (core_matching);
2038 free (core_matching);
2045 /* Add a name to the section renaming list. */
2048 add_section_rename (const char * old_name, const char * new_name,
2051 section_rename * rename;
2053 /* Check for conflicts first. */
2054 for (rename = section_rename_list; rename != NULL; rename = rename->next)
2055 if (strcmp (rename->old_name, old_name) == 0)
2057 /* Silently ignore duplicate definitions. */
2058 if (strcmp (rename->new_name, new_name) == 0
2059 && rename->flags == flags)
2062 fatal (_("Multiple renames of section %s"), old_name);
2065 rename = xmalloc (sizeof (* rename));
2067 rename->old_name = old_name;
2068 rename->new_name = new_name;
2069 rename->flags = flags;
2070 rename->next = section_rename_list;
2072 section_rename_list = rename;
2075 /* Check the section rename list for a new name of the input section
2076 ISECTION. Return the new name if one is found.
2077 Also set RETURNED_FLAGS to the flags to be used for this section. */
2080 find_section_rename (bfd * ibfd ATTRIBUTE_UNUSED, sec_ptr isection,
2081 flagword * returned_flags)
2083 const char * old_name = bfd_section_name (ibfd, isection);
2084 section_rename * rename;
2086 /* Default to using the flags of the input section. */
2087 * returned_flags = bfd_get_section_flags (ibfd, isection);
2089 for (rename = section_rename_list; rename != NULL; rename = rename->next)
2090 if (strcmp (rename->old_name, old_name) == 0)
2092 if (rename->flags != (flagword) -1)
2093 * returned_flags = rename->flags;
2095 return rename->new_name;
2101 /* Once each of the sections is copied, we may still need to do some
2102 finalization work for private section headers. Do that here. */
2105 setup_bfd_headers (bfd *ibfd, bfd *obfd)
2109 /* Allow the BFD backend to copy any private data it understands
2110 from the input section to the output section. */
2111 if (! bfd_copy_private_header_data (ibfd, obfd))
2113 err = _("private header data");
2117 /* All went well. */
2121 non_fatal (_("%s: error in %s: %s"),
2122 bfd_get_filename (ibfd),
2123 err, bfd_errmsg (bfd_get_error ()));
2127 /* Create a section in OBFD with the same
2128 name and attributes as ISECTION in IBFD. */
2131 setup_section (bfd *ibfd, sec_ptr isection, void *obfdarg)
2133 bfd *obfd = obfdarg;
2134 struct section_list *p;
2142 char *prefix = NULL;
2144 if (is_strip_section (ibfd, isection))
2147 p = find_section_list (bfd_section_name (ibfd, isection), FALSE);
2151 /* Get the, possibly new, name of the output section. */
2152 name = find_section_rename (ibfd, isection, & flags);
2154 /* Prefix sections. */
2155 if ((prefix_alloc_sections_string)
2156 && (bfd_get_section_flags (ibfd, isection) & SEC_ALLOC))
2157 prefix = prefix_alloc_sections_string;
2158 else if (prefix_sections_string)
2159 prefix = prefix_sections_string;
2165 n = xmalloc (strlen (prefix) + strlen (name) + 1);
2171 if (p != NULL && p->set_flags)
2172 flags = p->flags | (flags & (SEC_HAS_CONTENTS | SEC_RELOC));
2173 else if (strip_symbols == STRIP_NONDEBUG && (flags & SEC_ALLOC) != 0)
2174 flags &= ~(SEC_HAS_CONTENTS | SEC_LOAD);
2176 osection = bfd_make_section_anyway_with_flags (obfd, name, flags);
2178 if (osection == NULL)
2184 if (strip_symbols == STRIP_NONDEBUG
2185 && obfd->xvec->flavour == bfd_target_elf_flavour
2186 && (flags & SEC_ALLOC) != 0
2187 && (p == NULL || !p->set_flags))
2188 elf_section_type (osection) = SHT_NOBITS;
2190 size = bfd_section_size (ibfd, isection);
2192 size = (size + interleave - 1) / interleave;
2193 if (! bfd_set_section_size (obfd, osection, size))
2199 vma = bfd_section_vma (ibfd, isection);
2200 if (p != NULL && p->change_vma == CHANGE_MODIFY)
2202 else if (p != NULL && p->change_vma == CHANGE_SET)
2205 vma += change_section_address;
2207 if (! bfd_set_section_vma (obfd, osection, vma))
2213 lma = isection->lma;
2214 if ((p != NULL) && p->change_lma != CHANGE_IGNORE)
2216 if (p->change_lma == CHANGE_MODIFY)
2218 else if (p->change_lma == CHANGE_SET)
2224 lma += change_section_address;
2226 osection->lma = lma;
2228 /* FIXME: This is probably not enough. If we change the LMA we
2229 may have to recompute the header for the file as well. */
2230 if (!bfd_set_section_alignment (obfd,
2232 bfd_section_alignment (ibfd, isection)))
2234 err = _("alignment");
2238 /* Copy merge entity size. */
2239 osection->entsize = isection->entsize;
2241 /* This used to be mangle_section; we do here to avoid using
2242 bfd_get_section_by_name since some formats allow multiple
2243 sections with the same name. */
2244 isection->output_section = osection;
2245 isection->output_offset = 0;
2247 /* Allow the BFD backend to copy any private data it understands
2248 from the input section to the output section. */
2249 if (bfd_get_flavour (ibfd) == bfd_target_elf_flavour
2250 && strip_symbols == STRIP_NONDEBUG)
2251 /* Do not copy the private data when creating an ELF format
2252 debug info file. We do not want the program headers. */
2254 else if (!bfd_copy_private_section_data (ibfd, isection, obfd, osection))
2256 err = _("private data");
2259 else if ((isection->flags & SEC_GROUP) != 0)
2261 asymbol *gsym = group_signature (isection);
2264 gsym->flags |= BSF_KEEP;
2267 /* All went well. */
2271 non_fatal (_("%s: section `%s': error in %s: %s"),
2272 bfd_get_filename (ibfd),
2273 bfd_section_name (ibfd, isection),
2274 err, bfd_errmsg (bfd_get_error ()));
2278 /* Copy the data of input section ISECTION of IBFD
2279 to an output section with the same name in OBFD.
2280 If stripping then don't copy any relocation info. */
2283 copy_section (bfd *ibfd, sec_ptr isection, void *obfdarg)
2285 bfd *obfd = obfdarg;
2286 struct section_list *p;
2294 /* If we have already failed earlier on,
2295 do not keep on generating complaints now. */
2299 if (is_strip_section (ibfd, isection))
2302 flags = bfd_get_section_flags (ibfd, isection);
2303 if ((flags & SEC_GROUP) != 0)
2306 osection = isection->output_section;
2307 size = bfd_get_section_size (isection);
2309 if (size == 0 || osection == 0)
2312 p = find_section_list (bfd_get_section_name (ibfd, isection), FALSE);
2314 /* Core files do not need to be relocated. */
2315 if (bfd_get_format (obfd) == bfd_core)
2319 relsize = bfd_get_reloc_upper_bound (ibfd, isection);
2323 /* Do not complain if the target does not support relocations. */
2324 if (relsize == -1 && bfd_get_error () == bfd_error_invalid_operation)
2327 RETURN_NONFATAL (bfd_get_filename (ibfd));
2332 bfd_set_reloc (obfd, osection, NULL, 0);
2335 relpp = xmalloc (relsize);
2336 relcount = bfd_canonicalize_reloc (ibfd, isection, relpp, isympp);
2338 RETURN_NONFATAL (bfd_get_filename (ibfd));
2340 if (strip_symbols == STRIP_ALL)
2342 /* Remove relocations which are not in
2343 keep_strip_specific_list. */
2344 arelent **temp_relpp;
2345 long temp_relcount = 0;
2348 temp_relpp = xmalloc (relsize);
2349 for (i = 0; i < relcount; i++)
2350 if (is_specified_symbol (bfd_asymbol_name (*relpp[i]->sym_ptr_ptr),
2351 keep_specific_list))
2352 temp_relpp [temp_relcount++] = relpp [i];
2353 relcount = temp_relcount;
2358 bfd_set_reloc (obfd, osection, relcount == 0 ? NULL : relpp, relcount);
2363 if (bfd_get_section_flags (ibfd, isection) & SEC_HAS_CONTENTS
2364 && bfd_get_section_flags (obfd, osection) & SEC_HAS_CONTENTS)
2366 void *memhunk = xmalloc (size);
2368 if (!bfd_get_section_contents (ibfd, isection, memhunk, 0, size))
2369 RETURN_NONFATAL (bfd_get_filename (ibfd));
2373 /* Keep only every `copy_byte'th byte in MEMHUNK. */
2374 char *from = (char *) memhunk + copy_byte;
2376 char *end = (char *) memhunk + size;
2378 for (; from < end; from += interleave)
2381 size = (size + interleave - 1 - copy_byte) / interleave;
2382 osection->lma /= interleave;
2385 if (!bfd_set_section_contents (obfd, osection, memhunk, 0, size))
2386 RETURN_NONFATAL (bfd_get_filename (obfd));
2390 else if (p != NULL && p->set_flags && (p->flags & SEC_HAS_CONTENTS) != 0)
2392 void *memhunk = xmalloc (size);
2394 /* We don't permit the user to turn off the SEC_HAS_CONTENTS
2395 flag--they can just remove the section entirely and add it
2396 back again. However, we do permit them to turn on the
2397 SEC_HAS_CONTENTS flag, and take it to mean that the section
2398 contents should be zeroed out. */
2400 memset (memhunk, 0, size);
2401 if (! bfd_set_section_contents (obfd, osection, memhunk, 0, size))
2402 RETURN_NONFATAL (bfd_get_filename (obfd));
2407 /* Get all the sections. This is used when --gap-fill or --pad-to is
2411 get_sections (bfd *obfd ATTRIBUTE_UNUSED, asection *osection, void *secppparg)
2413 asection ***secppp = secppparg;
2415 **secppp = osection;
2419 /* Sort sections by VMA. This is called via qsort, and is used when
2420 --gap-fill or --pad-to is used. We force non loadable or empty
2421 sections to the front, where they are easier to ignore. */
2424 compare_section_lma (const void *arg1, const void *arg2)
2426 const asection *const *sec1 = arg1;
2427 const asection *const *sec2 = arg2;
2428 flagword flags1, flags2;
2430 /* Sort non loadable sections to the front. */
2431 flags1 = (*sec1)->flags;
2432 flags2 = (*sec2)->flags;
2433 if ((flags1 & SEC_HAS_CONTENTS) == 0
2434 || (flags1 & SEC_LOAD) == 0)
2436 if ((flags2 & SEC_HAS_CONTENTS) != 0
2437 && (flags2 & SEC_LOAD) != 0)
2442 if ((flags2 & SEC_HAS_CONTENTS) == 0
2443 || (flags2 & SEC_LOAD) == 0)
2447 /* Sort sections by LMA. */
2448 if ((*sec1)->lma > (*sec2)->lma)
2450 else if ((*sec1)->lma < (*sec2)->lma)
2453 /* Sort sections with the same LMA by size. */
2454 if (bfd_get_section_size (*sec1) > bfd_get_section_size (*sec2))
2456 else if (bfd_get_section_size (*sec1) < bfd_get_section_size (*sec2))
2462 /* Mark all the symbols which will be used in output relocations with
2463 the BSF_KEEP flag so that those symbols will not be stripped.
2465 Ignore relocations which will not appear in the output file. */
2468 mark_symbols_used_in_relocations (bfd *ibfd, sec_ptr isection, void *symbolsarg)
2470 asymbol **symbols = symbolsarg;
2475 /* Ignore an input section with no corresponding output section. */
2476 if (isection->output_section == NULL)
2479 relsize = bfd_get_reloc_upper_bound (ibfd, isection);
2482 /* Do not complain if the target does not support relocations. */
2483 if (relsize == -1 && bfd_get_error () == bfd_error_invalid_operation)
2485 bfd_fatal (bfd_get_filename (ibfd));
2491 relpp = xmalloc (relsize);
2492 relcount = bfd_canonicalize_reloc (ibfd, isection, relpp, symbols);
2494 bfd_fatal (bfd_get_filename (ibfd));
2496 /* Examine each symbol used in a relocation. If it's not one of the
2497 special bfd section symbols, then mark it with BSF_KEEP. */
2498 for (i = 0; i < relcount; i++)
2500 if (*relpp[i]->sym_ptr_ptr != bfd_com_section_ptr->symbol
2501 && *relpp[i]->sym_ptr_ptr != bfd_abs_section_ptr->symbol
2502 && *relpp[i]->sym_ptr_ptr != bfd_und_section_ptr->symbol)
2503 (*relpp[i]->sym_ptr_ptr)->flags |= BSF_KEEP;
2510 /* Write out debugging information. */
2513 write_debugging_info (bfd *obfd, void *dhandle,
2514 long *symcountp ATTRIBUTE_UNUSED,
2515 asymbol ***symppp ATTRIBUTE_UNUSED)
2517 if (bfd_get_flavour (obfd) == bfd_target_ieee_flavour)
2518 return write_ieee_debugging_info (obfd, dhandle);
2520 if (bfd_get_flavour (obfd) == bfd_target_coff_flavour
2521 || bfd_get_flavour (obfd) == bfd_target_elf_flavour)
2523 bfd_byte *syms, *strings;
2524 bfd_size_type symsize, stringsize;
2525 asection *stabsec, *stabstrsec;
2528 if (! write_stabs_in_sections_debugging_info (obfd, dhandle, &syms,
2533 flags = SEC_HAS_CONTENTS | SEC_READONLY | SEC_DEBUGGING;
2534 stabsec = bfd_make_section_with_flags (obfd, ".stab", flags);
2535 stabstrsec = bfd_make_section_with_flags (obfd, ".stabstr", flags);
2537 || stabstrsec == NULL
2538 || ! bfd_set_section_size (obfd, stabsec, symsize)
2539 || ! bfd_set_section_size (obfd, stabstrsec, stringsize)
2540 || ! bfd_set_section_alignment (obfd, stabsec, 2)
2541 || ! bfd_set_section_alignment (obfd, stabstrsec, 0))
2543 non_fatal (_("%s: can't create debugging section: %s"),
2544 bfd_get_filename (obfd),
2545 bfd_errmsg (bfd_get_error ()));
2549 /* We can get away with setting the section contents now because
2550 the next thing the caller is going to do is copy over the
2551 real sections. We may someday have to split the contents
2552 setting out of this function. */
2553 if (! bfd_set_section_contents (obfd, stabsec, syms, 0, symsize)
2554 || ! bfd_set_section_contents (obfd, stabstrsec, strings, 0,
2557 non_fatal (_("%s: can't set debugging section contents: %s"),
2558 bfd_get_filename (obfd),
2559 bfd_errmsg (bfd_get_error ()));
2566 non_fatal (_("%s: don't know how to write debugging information for %s"),
2567 bfd_get_filename (obfd), bfd_get_target (obfd));
2572 strip_main (int argc, char *argv[])
2574 char *input_target = NULL;
2575 char *output_target = NULL;
2576 bfd_boolean show_version = FALSE;
2577 bfd_boolean formats_info = FALSE;
2580 struct section_list *p;
2581 char *output_file = NULL;
2583 while ((c = getopt_long (argc, argv, "I:O:F:K:N:R:o:sSpdgxXHhVvw",
2584 strip_options, (int *) 0)) != EOF)
2589 input_target = optarg;
2592 output_target = optarg;
2595 input_target = output_target = optarg;
2598 p = find_section_list (optarg, TRUE);
2600 sections_removed = TRUE;
2603 strip_symbols = STRIP_ALL;
2607 case 'd': /* Historic BSD alias for -g. Used by early NetBSD. */
2608 strip_symbols = STRIP_DEBUG;
2610 case OPTION_STRIP_UNNEEDED:
2611 strip_symbols = STRIP_UNNEEDED;
2614 add_specific_symbol (optarg, &keep_specific_list);
2617 add_specific_symbol (optarg, &strip_specific_list);
2620 output_file = optarg;
2623 preserve_dates = TRUE;
2626 discard_locals = LOCALS_ALL;
2629 discard_locals = LOCALS_START_L;
2635 show_version = TRUE;
2637 case OPTION_FORMATS_INFO:
2638 formats_info = TRUE;
2640 case OPTION_ONLY_KEEP_DEBUG:
2641 strip_symbols = STRIP_NONDEBUG;
2643 case OPTION_KEEP_FILE_SYMBOLS:
2644 keep_file_symbols = 1;
2647 /* We've been given a long option. */
2654 strip_usage (stdout, 0);
2656 strip_usage (stderr, 1);
2667 print_version ("strip");
2669 /* Default is to strip all symbols. */
2670 if (strip_symbols == STRIP_UNDEF
2671 && discard_locals == LOCALS_UNDEF
2672 && strip_specific_list == NULL)
2673 strip_symbols = STRIP_ALL;
2675 if (output_target == NULL)
2676 output_target = input_target;
2680 || (output_file != NULL && (i + 1) < argc))
2681 strip_usage (stderr, 1);
2683 for (; i < argc; i++)
2685 int hold_status = status;
2686 struct stat statbuf;
2689 if (get_file_size (argv[i]) < 1)
2696 /* No need to check the return value of stat().
2697 It has already been checked in get_file_size(). */
2698 stat (argv[i], &statbuf);
2700 if (output_file != NULL)
2701 tmpname = output_file;
2703 tmpname = make_tempname (argv[i]);
2706 copy_file (argv[i], tmpname, input_target, output_target);
2710 set_times (tmpname, &statbuf);
2711 if (output_file == NULL)
2712 smart_rename (tmpname, argv[i], preserve_dates);
2713 status = hold_status;
2716 unlink_if_ordinary (tmpname);
2717 if (output_file == NULL)
2725 copy_main (int argc, char *argv[])
2727 char * binary_architecture = NULL;
2728 char *input_filename = NULL;
2729 char *output_filename = NULL;
2730 char *input_target = NULL;
2731 char *output_target = NULL;
2732 bfd_boolean show_version = FALSE;
2733 bfd_boolean change_warn = TRUE;
2734 bfd_boolean formats_info = FALSE;
2736 struct section_list *p;
2737 struct stat statbuf;
2739 while ((c = getopt_long (argc, argv, "b:B:i:I:j:K:N:s:O:d:F:L:G:R:SpgxXHhVvW:w",
2740 copy_options, (int *) 0)) != EOF)
2745 copy_byte = atoi (optarg);
2747 fatal (_("byte number must be non-negative"));
2751 binary_architecture = optarg;
2755 interleave = atoi (optarg);
2757 fatal (_("interleave must be positive"));
2761 case 's': /* "source" - 'I' is preferred */
2762 input_target = optarg;
2766 case 'd': /* "destination" - 'O' is preferred */
2767 output_target = optarg;
2771 input_target = output_target = optarg;
2775 p = find_section_list (optarg, TRUE);
2777 fatal (_("%s both copied and removed"), optarg);
2779 sections_copied = TRUE;
2783 p = find_section_list (optarg, TRUE);
2785 fatal (_("%s both copied and removed"), optarg);
2787 sections_removed = TRUE;
2791 strip_symbols = STRIP_ALL;
2795 strip_symbols = STRIP_DEBUG;
2798 case OPTION_STRIP_UNNEEDED:
2799 strip_symbols = STRIP_UNNEEDED;
2802 case OPTION_ONLY_KEEP_DEBUG:
2803 strip_symbols = STRIP_NONDEBUG;
2806 case OPTION_KEEP_FILE_SYMBOLS:
2807 keep_file_symbols = 1;
2810 case OPTION_ADD_GNU_DEBUGLINK:
2811 gnu_debuglink_filename = optarg;
2815 add_specific_symbol (optarg, &keep_specific_list);
2819 add_specific_symbol (optarg, &strip_specific_list);
2822 case OPTION_STRIP_UNNEEDED_SYMBOL:
2823 add_specific_symbol (optarg, &strip_unneeded_list);
2827 add_specific_symbol (optarg, &localize_specific_list);
2830 case OPTION_GLOBALIZE_SYMBOL:
2831 add_specific_symbol (optarg, &globalize_specific_list);
2835 add_specific_symbol (optarg, &keepglobal_specific_list);
2839 add_specific_symbol (optarg, &weaken_specific_list);
2843 preserve_dates = TRUE;
2851 discard_locals = LOCALS_ALL;
2855 discard_locals = LOCALS_START_L;
2863 show_version = TRUE;
2866 case OPTION_FORMATS_INFO:
2867 formats_info = TRUE;
2874 case OPTION_ADD_SECTION:
2878 struct section_add *pa;
2883 s = strchr (optarg, '=');
2886 fatal (_("bad format for %s"), "--add-section");
2888 size = get_file_size (s + 1);
2895 pa = xmalloc (sizeof (struct section_add));
2898 name = xmalloc (len + 1);
2899 strncpy (name, optarg, len);
2903 pa->filename = s + 1;
2905 pa->contents = xmalloc (size);
2907 f = fopen (pa->filename, FOPEN_RB);
2910 fatal (_("cannot open: %s: %s"),
2911 pa->filename, strerror (errno));
2913 if (fread (pa->contents, 1, pa->size, f) == 0
2915 fatal (_("%s: fread failed"), pa->filename);
2919 pa->next = add_sections;
2924 case OPTION_CHANGE_START:
2925 change_start = parse_vma (optarg, "--change-start");
2928 case OPTION_CHANGE_SECTION_ADDRESS:
2929 case OPTION_CHANGE_SECTION_LMA:
2930 case OPTION_CHANGE_SECTION_VMA:
2935 char *option = NULL;
2937 enum change_action what = CHANGE_IGNORE;
2941 case OPTION_CHANGE_SECTION_ADDRESS:
2942 option = "--change-section-address";
2944 case OPTION_CHANGE_SECTION_LMA:
2945 option = "--change-section-lma";
2947 case OPTION_CHANGE_SECTION_VMA:
2948 option = "--change-section-vma";
2952 s = strchr (optarg, '=');
2955 s = strchr (optarg, '+');
2958 s = strchr (optarg, '-');
2960 fatal (_("bad format for %s"), option);
2965 name = xmalloc (len + 1);
2966 strncpy (name, optarg, len);
2969 p = find_section_list (name, TRUE);
2971 val = parse_vma (s + 1, option);
2975 case '=': what = CHANGE_SET; break;
2976 case '-': val = - val; /* Drop through. */
2977 case '+': what = CHANGE_MODIFY; break;
2982 case OPTION_CHANGE_SECTION_ADDRESS:
2983 p->change_vma = what;
2987 case OPTION_CHANGE_SECTION_LMA:
2988 p->change_lma = what;
2992 case OPTION_CHANGE_SECTION_VMA:
2993 p->change_vma = what;
3000 case OPTION_CHANGE_ADDRESSES:
3001 change_section_address = parse_vma (optarg, "--change-addresses");
3002 change_start = change_section_address;
3005 case OPTION_CHANGE_WARNINGS:
3009 case OPTION_CHANGE_LEADING_CHAR:
3010 change_leading_char = TRUE;
3013 case OPTION_DEBUGGING:
3014 convert_debugging = TRUE;
3017 case OPTION_GAP_FILL:
3019 bfd_vma gap_fill_vma;
3021 gap_fill_vma = parse_vma (optarg, "--gap-fill");
3022 gap_fill = (bfd_byte) gap_fill_vma;
3023 if ((bfd_vma) gap_fill != gap_fill_vma)
3027 sprintf_vma (buff, gap_fill_vma);
3029 non_fatal (_("Warning: truncating gap-fill from 0x%s to 0x%x"),
3032 gap_fill_set = TRUE;
3036 case OPTION_NO_CHANGE_WARNINGS:
3037 change_warn = FALSE;
3041 pad_to = parse_vma (optarg, "--pad-to");
3045 case OPTION_REMOVE_LEADING_CHAR:
3046 remove_leading_char = TRUE;
3049 case OPTION_REDEFINE_SYM:
3051 /* Push this redefinition onto redefine_symbol_list. */
3055 const char *nextarg;
3056 char *source, *target;
3058 s = strchr (optarg, '=');
3060 fatal (_("bad format for %s"), "--redefine-sym");
3063 source = xmalloc (len + 1);
3064 strncpy (source, optarg, len);
3068 len = strlen (nextarg);
3069 target = xmalloc (len + 1);
3070 strcpy (target, nextarg);
3072 redefine_list_append ("--redefine-sym", source, target);
3079 case OPTION_REDEFINE_SYMS:
3080 add_redefine_syms_file (optarg);
3083 case OPTION_SET_SECTION_FLAGS:
3089 s = strchr (optarg, '=');
3091 fatal (_("bad format for %s"), "--set-section-flags");
3094 name = xmalloc (len + 1);
3095 strncpy (name, optarg, len);
3098 p = find_section_list (name, TRUE);
3100 p->set_flags = TRUE;
3101 p->flags = parse_flags (s + 1);
3105 case OPTION_RENAME_SECTION:
3108 const char *eq, *fl;
3113 eq = strchr (optarg, '=');
3115 fatal (_("bad format for %s"), "--rename-section");
3119 fatal (_("bad format for %s"), "--rename-section");
3121 old_name = xmalloc (len + 1);
3122 strncpy (old_name, optarg, len);
3126 fl = strchr (eq, ',');
3129 flags = parse_flags (fl + 1);
3139 fatal (_("bad format for %s"), "--rename-section");
3141 new_name = xmalloc (len + 1);
3142 strncpy (new_name, eq, len);
3145 add_section_rename (old_name, new_name, flags);
3149 case OPTION_SET_START:
3150 set_start = parse_vma (optarg, "--set-start");
3151 set_start_set = TRUE;
3154 case OPTION_SREC_LEN:
3155 Chunk = parse_vma (optarg, "--srec-len");
3158 case OPTION_SREC_FORCES3:
3162 case OPTION_STRIP_SYMBOLS:
3163 add_specific_symbols (optarg, &strip_specific_list);
3166 case OPTION_STRIP_UNNEEDED_SYMBOLS:
3167 add_specific_symbols (optarg, &strip_unneeded_list);
3170 case OPTION_KEEP_SYMBOLS:
3171 add_specific_symbols (optarg, &keep_specific_list);
3174 case OPTION_LOCALIZE_HIDDEN:
3175 localize_hidden = TRUE;
3178 case OPTION_LOCALIZE_SYMBOLS:
3179 add_specific_symbols (optarg, &localize_specific_list);
3182 case OPTION_GLOBALIZE_SYMBOLS:
3183 add_specific_symbols (optarg, &globalize_specific_list);
3186 case OPTION_KEEPGLOBAL_SYMBOLS:
3187 add_specific_symbols (optarg, &keepglobal_specific_list);
3190 case OPTION_WEAKEN_SYMBOLS:
3191 add_specific_symbols (optarg, &weaken_specific_list);
3194 case OPTION_ALT_MACH_CODE:
3195 use_alt_mach_code = strtoul (optarg, NULL, 0);
3196 if (use_alt_mach_code == 0)
3197 fatal (_("unable to parse alternative machine code"));
3200 case OPTION_PREFIX_SYMBOLS:
3201 prefix_symbols_string = optarg;
3204 case OPTION_PREFIX_SECTIONS:
3205 prefix_sections_string = optarg;
3208 case OPTION_PREFIX_ALLOC_SECTIONS:
3209 prefix_alloc_sections_string = optarg;
3212 case OPTION_READONLY_TEXT:
3213 bfd_flags_to_set |= WP_TEXT;
3214 bfd_flags_to_clear &= ~WP_TEXT;
3217 case OPTION_WRITABLE_TEXT:
3218 bfd_flags_to_clear |= WP_TEXT;
3219 bfd_flags_to_set &= ~WP_TEXT;
3223 bfd_flags_to_set |= D_PAGED;
3224 bfd_flags_to_clear &= ~D_PAGED;
3228 bfd_flags_to_clear |= D_PAGED;
3229 bfd_flags_to_set &= ~D_PAGED;
3233 /* We've been given a long option. */
3238 copy_usage (stdout, 0);
3241 copy_usage (stderr, 1);
3252 print_version ("objcopy");
3254 if (copy_byte >= interleave)
3255 fatal (_("byte number must be less than interleave"));
3257 if (optind == argc || optind + 2 < argc)
3258 copy_usage (stderr, 1);
3260 input_filename = argv[optind];
3261 if (optind + 1 < argc)
3262 output_filename = argv[optind + 1];
3264 /* Default is to strip no symbols. */
3265 if (strip_symbols == STRIP_UNDEF && discard_locals == LOCALS_UNDEF)
3266 strip_symbols = STRIP_NONE;
3268 if (output_target == NULL)
3269 output_target = input_target;
3271 if (binary_architecture != NULL)
3273 if (input_target && strcmp (input_target, "binary") == 0)
3275 const bfd_arch_info_type * temp_arch_info;
3277 temp_arch_info = bfd_scan_arch (binary_architecture);
3279 if (temp_arch_info != NULL)
3281 bfd_external_binary_architecture = temp_arch_info->arch;
3282 bfd_external_machine = temp_arch_info->mach;
3285 fatal (_("architecture %s unknown"), binary_architecture);
3289 non_fatal (_("Warning: input target 'binary' required for binary architecture parameter."));
3290 non_fatal (_(" Argument %s ignored"), binary_architecture);
3295 if (stat (input_filename, & statbuf) < 0)
3296 fatal (_("warning: could not locate '%s'. System error message: %s"),
3297 input_filename, strerror (errno));
3299 /* If there is no destination file, or the source and destination files
3300 are the same, then create a temp and rename the result into the input. */
3301 if (output_filename == NULL || strcmp (input_filename, output_filename) == 0)
3303 char *tmpname = make_tempname (input_filename);
3305 copy_file (input_filename, tmpname, input_target, output_target);
3309 set_times (tmpname, &statbuf);
3310 smart_rename (tmpname, input_filename, preserve_dates);
3317 copy_file (input_filename, output_filename, input_target, output_target);
3319 if (status == 0 && preserve_dates)
3320 set_times (output_filename, &statbuf);
3321 else if (status != 0)
3322 unlink_if_ordinary (output_filename);
3327 for (p = change_sections; p != NULL; p = p->next)
3331 if (p->change_vma != CHANGE_IGNORE)
3335 sprintf_vma (buff, p->vma_val);
3337 /* xgettext:c-format */
3338 non_fatal (_("%s %s%c0x%s never used"),
3339 "--change-section-vma",
3341 p->change_vma == CHANGE_SET ? '=' : '+',
3345 if (p->change_lma != CHANGE_IGNORE)
3349 sprintf_vma (buff, p->lma_val);
3351 /* xgettext:c-format */
3352 non_fatal (_("%s %s%c0x%s never used"),
3353 "--change-section-lma",
3355 p->change_lma == CHANGE_SET ? '=' : '+',
3366 main (int argc, char *argv[])
3368 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
3369 setlocale (LC_MESSAGES, "");
3371 #if defined (HAVE_SETLOCALE)
3372 setlocale (LC_CTYPE, "");
3374 bindtextdomain (PACKAGE, LOCALEDIR);
3375 textdomain (PACKAGE);
3377 program_name = argv[0];
3378 xmalloc_set_program_name (program_name);
3380 START_PROGRESS (program_name, 0);
3382 expandargv (&argc, &argv);
3384 strip_symbols = STRIP_UNDEF;
3385 discard_locals = LOCALS_UNDEF;
3388 set_default_bfd_target ();
3392 int i = strlen (program_name);
3393 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
3394 /* Drop the .exe suffix, if any. */
3395 if (i > 4 && FILENAME_CMP (program_name + i - 4, ".exe") == 0)
3398 program_name[i] = '\0';
3401 is_strip = (i >= 5 && FILENAME_CMP (program_name + i - 5, "strip") == 0);
3405 strip_main (argc, argv);
3407 copy_main (argc, argv);
3409 END_PROGRESS (program_name);