2011-06-29 Tristan Gingold <gingold@adacore.com>
[binutils.git] / binutils / objcopy.c
blobb64f3d046c42e7014715a6b8d7a89b4fc8101392
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, 2007, 2008, 2009, 2010, 2011
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 3 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 "sysdep.h"
24 #include "bfd.h"
25 #include "progress.h"
26 #include "getopt.h"
27 #include "libiberty.h"
28 #include "bucomm.h"
29 #include "budbg.h"
30 #include "filenames.h"
31 #include "fnmatch.h"
32 #include "elf-bfd.h"
33 #include <sys/stat.h>
34 #include "libbfd.h"
35 #include "coff/internal.h"
36 #include "libcoff.h"
38 /* FIXME: See bfd/peXXigen.c for why we include an architecture specific
39 header in generic PE code. */
40 #include "coff/i386.h"
41 #include "coff/pe.h"
43 static bfd_vma pe_file_alignment = (bfd_vma) -1;
44 static bfd_vma pe_heap_commit = (bfd_vma) -1;
45 static bfd_vma pe_heap_reserve = (bfd_vma) -1;
46 static bfd_vma pe_image_base = (bfd_vma) -1;
47 static bfd_vma pe_section_alignment = (bfd_vma) -1;
48 static bfd_vma pe_stack_commit = (bfd_vma) -1;
49 static bfd_vma pe_stack_reserve = (bfd_vma) -1;
50 static short pe_subsystem = -1;
51 static short pe_major_subsystem_version = -1;
52 static short pe_minor_subsystem_version = -1;
54 struct is_specified_symbol_predicate_data
56 const char *name;
57 bfd_boolean found;
60 /* A list to support redefine_sym. */
61 struct redefine_node
63 char *source;
64 char *target;
65 struct redefine_node *next;
68 typedef struct section_rename
70 const char * old_name;
71 const char * new_name;
72 flagword flags;
73 struct section_rename * next;
75 section_rename;
77 /* List of sections to be renamed. */
78 static section_rename *section_rename_list;
80 static asymbol **isympp = NULL; /* Input symbols. */
81 static asymbol **osympp = NULL; /* Output symbols that survive stripping. */
83 /* If `copy_byte' >= 0, copy 'copy_width' byte(s) of every `interleave' bytes. */
84 static int copy_byte = -1;
85 static int interleave = 0; /* Initialised to 4 in copy_main(). */
86 static int copy_width = 1;
88 static bfd_boolean verbose; /* Print file and target names. */
89 static bfd_boolean preserve_dates; /* Preserve input file timestamp. */
90 static int status = 0; /* Exit status. */
92 enum strip_action
94 STRIP_UNDEF,
95 STRIP_NONE, /* Don't strip. */
96 STRIP_DEBUG, /* Strip all debugger symbols. */
97 STRIP_UNNEEDED, /* Strip unnecessary symbols. */
98 STRIP_NONDEBUG, /* Strip everything but debug info. */
99 STRIP_ALL /* Strip all symbols. */
102 /* Which symbols to remove. */
103 static enum strip_action strip_symbols;
105 enum locals_action
107 LOCALS_UNDEF,
108 LOCALS_START_L, /* Discard locals starting with L. */
109 LOCALS_ALL /* Discard all locals. */
112 /* Which local symbols to remove. Overrides STRIP_ALL. */
113 static enum locals_action discard_locals;
115 /* What kind of change to perform. */
116 enum change_action
118 CHANGE_IGNORE,
119 CHANGE_MODIFY,
120 CHANGE_SET
123 /* Structure used to hold lists of sections and actions to take. */
124 struct section_list
126 struct section_list * next; /* Next section to change. */
127 const char * name; /* Section name. */
128 bfd_boolean used; /* Whether this entry was used. */
129 bfd_boolean remove; /* Whether to remove this section. */
130 bfd_boolean copy; /* Whether to copy this section. */
131 enum change_action change_vma;/* Whether to change or set VMA. */
132 bfd_vma vma_val; /* Amount to change by or set to. */
133 enum change_action change_lma;/* Whether to change or set LMA. */
134 bfd_vma lma_val; /* Amount to change by or set to. */
135 bfd_boolean set_flags; /* Whether to set the section flags. */
136 flagword flags; /* What to set the section flags to. */
139 static struct section_list *change_sections;
141 /* TRUE if some sections are to be removed. */
142 static bfd_boolean sections_removed;
144 /* TRUE if only some sections are to be copied. */
145 static bfd_boolean sections_copied;
147 /* Changes to the start address. */
148 static bfd_vma change_start = 0;
149 static bfd_boolean set_start_set = FALSE;
150 static bfd_vma set_start;
152 /* Changes to section addresses. */
153 static bfd_vma change_section_address = 0;
155 /* Filling gaps between sections. */
156 static bfd_boolean gap_fill_set = FALSE;
157 static bfd_byte gap_fill = 0;
159 /* Pad to a given address. */
160 static bfd_boolean pad_to_set = FALSE;
161 static bfd_vma pad_to;
163 /* Use alternative machine code? */
164 static unsigned long use_alt_mach_code = 0;
166 /* Output BFD flags user wants to set or clear */
167 static flagword bfd_flags_to_set;
168 static flagword bfd_flags_to_clear;
170 /* List of sections to add. */
171 struct section_add
173 /* Next section to add. */
174 struct section_add *next;
175 /* Name of section to add. */
176 const char *name;
177 /* Name of file holding section contents. */
178 const char *filename;
179 /* Size of file. */
180 size_t size;
181 /* Contents of file. */
182 bfd_byte *contents;
183 /* BFD section, after it has been added. */
184 asection *section;
187 /* List of sections to add to the output BFD. */
188 static struct section_add *add_sections;
190 /* If non-NULL the argument to --add-gnu-debuglink.
191 This should be the filename to store in the .gnu_debuglink section. */
192 static const char * gnu_debuglink_filename = NULL;
194 /* Whether to convert debugging information. */
195 static bfd_boolean convert_debugging = FALSE;
197 /* Whether to compress/decompress DWARF debug sections. */
198 static enum
200 nothing,
201 compress,
202 decompress
203 } do_debug_sections = nothing;
205 /* Whether to change the leading character in symbol names. */
206 static bfd_boolean change_leading_char = FALSE;
208 /* Whether to remove the leading character from global symbol names. */
209 static bfd_boolean remove_leading_char = FALSE;
211 /* Whether to permit wildcard in symbol comparison. */
212 static bfd_boolean wildcard = FALSE;
214 /* True if --localize-hidden is in effect. */
215 static bfd_boolean localize_hidden = FALSE;
217 /* List of symbols to strip, keep, localize, keep-global, weaken,
218 or redefine. */
219 static htab_t strip_specific_htab = NULL;
220 static htab_t strip_unneeded_htab = NULL;
221 static htab_t keep_specific_htab = NULL;
222 static htab_t localize_specific_htab = NULL;
223 static htab_t globalize_specific_htab = NULL;
224 static htab_t keepglobal_specific_htab = NULL;
225 static htab_t weaken_specific_htab = NULL;
226 static struct redefine_node *redefine_sym_list = NULL;
228 /* If this is TRUE, we weaken global symbols (set BSF_WEAK). */
229 static bfd_boolean weaken = FALSE;
231 /* If this is TRUE, we retain BSF_FILE symbols. */
232 static bfd_boolean keep_file_symbols = FALSE;
234 /* Prefix symbols/sections. */
235 static char *prefix_symbols_string = 0;
236 static char *prefix_sections_string = 0;
237 static char *prefix_alloc_sections_string = 0;
239 /* True if --extract-symbol was passed on the command line. */
240 static bfd_boolean extract_symbol = FALSE;
242 /* If `reverse_bytes' is nonzero, then reverse the order of every chunk
243 of <reverse_bytes> bytes within each output section. */
244 static int reverse_bytes = 0;
246 /* For Coff objects, we may want to allow or disallow long section names,
247 or preserve them where found in the inputs. Debug info relies on them. */
248 enum long_section_name_handling
250 DISABLE,
251 ENABLE,
252 KEEP
255 /* The default long section handling mode is to preserve them.
256 This is also the only behaviour for 'strip'. */
257 static enum long_section_name_handling long_section_names = KEEP;
259 /* 150 isn't special; it's just an arbitrary non-ASCII char value. */
260 enum command_line_switch
262 OPTION_ADD_SECTION=150,
263 OPTION_CHANGE_ADDRESSES,
264 OPTION_CHANGE_LEADING_CHAR,
265 OPTION_CHANGE_START,
266 OPTION_CHANGE_SECTION_ADDRESS,
267 OPTION_CHANGE_SECTION_LMA,
268 OPTION_CHANGE_SECTION_VMA,
269 OPTION_CHANGE_WARNINGS,
270 OPTION_COMPRESS_DEBUG_SECTIONS,
271 OPTION_DEBUGGING,
272 OPTION_DECOMPRESS_DEBUG_SECTIONS,
273 OPTION_GAP_FILL,
274 OPTION_NO_CHANGE_WARNINGS,
275 OPTION_PAD_TO,
276 OPTION_REMOVE_LEADING_CHAR,
277 OPTION_SET_SECTION_FLAGS,
278 OPTION_SET_START,
279 OPTION_STRIP_UNNEEDED,
280 OPTION_WEAKEN,
281 OPTION_REDEFINE_SYM,
282 OPTION_REDEFINE_SYMS,
283 OPTION_SREC_LEN,
284 OPTION_SREC_FORCES3,
285 OPTION_STRIP_SYMBOLS,
286 OPTION_STRIP_UNNEEDED_SYMBOL,
287 OPTION_STRIP_UNNEEDED_SYMBOLS,
288 OPTION_KEEP_SYMBOLS,
289 OPTION_LOCALIZE_HIDDEN,
290 OPTION_LOCALIZE_SYMBOLS,
291 OPTION_LONG_SECTION_NAMES,
292 OPTION_GLOBALIZE_SYMBOL,
293 OPTION_GLOBALIZE_SYMBOLS,
294 OPTION_KEEPGLOBAL_SYMBOLS,
295 OPTION_WEAKEN_SYMBOLS,
296 OPTION_RENAME_SECTION,
297 OPTION_ALT_MACH_CODE,
298 OPTION_PREFIX_SYMBOLS,
299 OPTION_PREFIX_SECTIONS,
300 OPTION_PREFIX_ALLOC_SECTIONS,
301 OPTION_FORMATS_INFO,
302 OPTION_ADD_GNU_DEBUGLINK,
303 OPTION_ONLY_KEEP_DEBUG,
304 OPTION_KEEP_FILE_SYMBOLS,
305 OPTION_READONLY_TEXT,
306 OPTION_WRITABLE_TEXT,
307 OPTION_PURE,
308 OPTION_IMPURE,
309 OPTION_EXTRACT_SYMBOL,
310 OPTION_REVERSE_BYTES,
311 OPTION_FILE_ALIGNMENT,
312 OPTION_HEAP,
313 OPTION_IMAGE_BASE,
314 OPTION_SECTION_ALIGNMENT,
315 OPTION_STACK,
316 OPTION_INTERLEAVE_WIDTH,
317 OPTION_SUBSYSTEM
320 /* Options to handle if running as "strip". */
322 static struct option strip_options[] =
324 {"discard-all", no_argument, 0, 'x'},
325 {"discard-locals", no_argument, 0, 'X'},
326 {"format", required_argument, 0, 'F'}, /* Obsolete */
327 {"help", no_argument, 0, 'h'},
328 {"info", no_argument, 0, OPTION_FORMATS_INFO},
329 {"input-format", required_argument, 0, 'I'}, /* Obsolete */
330 {"input-target", required_argument, 0, 'I'},
331 {"keep-file-symbols", no_argument, 0, OPTION_KEEP_FILE_SYMBOLS},
332 {"keep-symbol", required_argument, 0, 'K'},
333 {"only-keep-debug", no_argument, 0, OPTION_ONLY_KEEP_DEBUG},
334 {"output-format", required_argument, 0, 'O'}, /* Obsolete */
335 {"output-target", required_argument, 0, 'O'},
336 {"output-file", required_argument, 0, 'o'},
337 {"preserve-dates", no_argument, 0, 'p'},
338 {"remove-section", required_argument, 0, 'R'},
339 {"strip-all", no_argument, 0, 's'},
340 {"strip-debug", no_argument, 0, 'S'},
341 {"strip-unneeded", no_argument, 0, OPTION_STRIP_UNNEEDED},
342 {"strip-symbol", required_argument, 0, 'N'},
343 {"target", required_argument, 0, 'F'},
344 {"verbose", no_argument, 0, 'v'},
345 {"version", no_argument, 0, 'V'},
346 {"wildcard", no_argument, 0, 'w'},
347 {0, no_argument, 0, 0}
350 /* Options to handle if running as "objcopy". */
352 static struct option copy_options[] =
354 {"add-gnu-debuglink", required_argument, 0, OPTION_ADD_GNU_DEBUGLINK},
355 {"add-section", required_argument, 0, OPTION_ADD_SECTION},
356 {"adjust-start", required_argument, 0, OPTION_CHANGE_START},
357 {"adjust-vma", required_argument, 0, OPTION_CHANGE_ADDRESSES},
358 {"adjust-section-vma", required_argument, 0, OPTION_CHANGE_SECTION_ADDRESS},
359 {"adjust-warnings", no_argument, 0, OPTION_CHANGE_WARNINGS},
360 {"alt-machine-code", required_argument, 0, OPTION_ALT_MACH_CODE},
361 {"binary-architecture", required_argument, 0, 'B'},
362 {"byte", required_argument, 0, 'b'},
363 {"change-addresses", required_argument, 0, OPTION_CHANGE_ADDRESSES},
364 {"change-leading-char", no_argument, 0, OPTION_CHANGE_LEADING_CHAR},
365 {"change-section-address", required_argument, 0, OPTION_CHANGE_SECTION_ADDRESS},
366 {"change-section-lma", required_argument, 0, OPTION_CHANGE_SECTION_LMA},
367 {"change-section-vma", required_argument, 0, OPTION_CHANGE_SECTION_VMA},
368 {"change-start", required_argument, 0, OPTION_CHANGE_START},
369 {"change-warnings", no_argument, 0, OPTION_CHANGE_WARNINGS},
370 {"compress-debug-sections", no_argument, 0, OPTION_COMPRESS_DEBUG_SECTIONS},
371 {"debugging", no_argument, 0, OPTION_DEBUGGING},
372 {"decompress-debug-sections", no_argument, 0, OPTION_DECOMPRESS_DEBUG_SECTIONS},
373 {"discard-all", no_argument, 0, 'x'},
374 {"discard-locals", no_argument, 0, 'X'},
375 {"extract-symbol", no_argument, 0, OPTION_EXTRACT_SYMBOL},
376 {"format", required_argument, 0, 'F'}, /* Obsolete */
377 {"gap-fill", required_argument, 0, OPTION_GAP_FILL},
378 {"globalize-symbol", required_argument, 0, OPTION_GLOBALIZE_SYMBOL},
379 {"globalize-symbols", required_argument, 0, OPTION_GLOBALIZE_SYMBOLS},
380 {"help", no_argument, 0, 'h'},
381 {"impure", no_argument, 0, OPTION_IMPURE},
382 {"info", no_argument, 0, OPTION_FORMATS_INFO},
383 {"input-format", required_argument, 0, 'I'}, /* Obsolete */
384 {"input-target", required_argument, 0, 'I'},
385 {"interleave", optional_argument, 0, 'i'},
386 {"interleave-width", required_argument, 0, OPTION_INTERLEAVE_WIDTH},
387 {"keep-file-symbols", no_argument, 0, OPTION_KEEP_FILE_SYMBOLS},
388 {"keep-global-symbol", required_argument, 0, 'G'},
389 {"keep-global-symbols", required_argument, 0, OPTION_KEEPGLOBAL_SYMBOLS},
390 {"keep-symbol", required_argument, 0, 'K'},
391 {"keep-symbols", required_argument, 0, OPTION_KEEP_SYMBOLS},
392 {"localize-hidden", no_argument, 0, OPTION_LOCALIZE_HIDDEN},
393 {"localize-symbol", required_argument, 0, 'L'},
394 {"localize-symbols", required_argument, 0, OPTION_LOCALIZE_SYMBOLS},
395 {"long-section-names", required_argument, 0, OPTION_LONG_SECTION_NAMES},
396 {"no-adjust-warnings", no_argument, 0, OPTION_NO_CHANGE_WARNINGS},
397 {"no-change-warnings", no_argument, 0, OPTION_NO_CHANGE_WARNINGS},
398 {"only-keep-debug", no_argument, 0, OPTION_ONLY_KEEP_DEBUG},
399 {"only-section", required_argument, 0, 'j'},
400 {"output-format", required_argument, 0, 'O'}, /* Obsolete */
401 {"output-target", required_argument, 0, 'O'},
402 {"pad-to", required_argument, 0, OPTION_PAD_TO},
403 {"prefix-symbols", required_argument, 0, OPTION_PREFIX_SYMBOLS},
404 {"prefix-sections", required_argument, 0, OPTION_PREFIX_SECTIONS},
405 {"prefix-alloc-sections", required_argument, 0, OPTION_PREFIX_ALLOC_SECTIONS},
406 {"preserve-dates", no_argument, 0, 'p'},
407 {"pure", no_argument, 0, OPTION_PURE},
408 {"readonly-text", no_argument, 0, OPTION_READONLY_TEXT},
409 {"redefine-sym", required_argument, 0, OPTION_REDEFINE_SYM},
410 {"redefine-syms", required_argument, 0, OPTION_REDEFINE_SYMS},
411 {"remove-leading-char", no_argument, 0, OPTION_REMOVE_LEADING_CHAR},
412 {"remove-section", required_argument, 0, 'R'},
413 {"rename-section", required_argument, 0, OPTION_RENAME_SECTION},
414 {"reverse-bytes", required_argument, 0, OPTION_REVERSE_BYTES},
415 {"set-section-flags", required_argument, 0, OPTION_SET_SECTION_FLAGS},
416 {"set-start", required_argument, 0, OPTION_SET_START},
417 {"srec-len", required_argument, 0, OPTION_SREC_LEN},
418 {"srec-forceS3", no_argument, 0, OPTION_SREC_FORCES3},
419 {"strip-all", no_argument, 0, 'S'},
420 {"strip-debug", no_argument, 0, 'g'},
421 {"strip-unneeded", no_argument, 0, OPTION_STRIP_UNNEEDED},
422 {"strip-unneeded-symbol", required_argument, 0, OPTION_STRIP_UNNEEDED_SYMBOL},
423 {"strip-unneeded-symbols", required_argument, 0, OPTION_STRIP_UNNEEDED_SYMBOLS},
424 {"strip-symbol", required_argument, 0, 'N'},
425 {"strip-symbols", required_argument, 0, OPTION_STRIP_SYMBOLS},
426 {"target", required_argument, 0, 'F'},
427 {"verbose", no_argument, 0, 'v'},
428 {"version", no_argument, 0, 'V'},
429 {"weaken", no_argument, 0, OPTION_WEAKEN},
430 {"weaken-symbol", required_argument, 0, 'W'},
431 {"weaken-symbols", required_argument, 0, OPTION_WEAKEN_SYMBOLS},
432 {"wildcard", no_argument, 0, 'w'},
433 {"writable-text", no_argument, 0, OPTION_WRITABLE_TEXT},
434 {"file-alignment", required_argument, 0, OPTION_FILE_ALIGNMENT},
435 {"heap", required_argument, 0, OPTION_HEAP},
436 {"image-base", required_argument, 0 , OPTION_IMAGE_BASE},
437 {"section-alignment", required_argument, 0, OPTION_SECTION_ALIGNMENT},
438 {"stack", required_argument, 0, OPTION_STACK},
439 {"subsystem", required_argument, 0, OPTION_SUBSYSTEM},
440 {0, no_argument, 0, 0}
443 /* IMPORTS */
444 extern char *program_name;
446 /* This flag distinguishes between strip and objcopy:
447 1 means this is 'strip'; 0 means this is 'objcopy'.
448 -1 means if we should use argv[0] to decide. */
449 extern int is_strip;
451 /* The maximum length of an S record. This variable is declared in srec.c
452 and can be modified by the --srec-len parameter. */
453 extern unsigned int Chunk;
455 /* Restrict the generation of Srecords to type S3 only.
456 This variable is declare in bfd/srec.c and can be toggled
457 on by the --srec-forceS3 command line switch. */
458 extern bfd_boolean S3Forced;
460 /* Forward declarations. */
461 static void setup_section (bfd *, asection *, void *);
462 static void setup_bfd_headers (bfd *, bfd *);
463 static void copy_section (bfd *, asection *, void *);
464 static void get_sections (bfd *, asection *, void *);
465 static int compare_section_lma (const void *, const void *);
466 static void mark_symbols_used_in_relocations (bfd *, asection *, void *);
467 static bfd_boolean write_debugging_info (bfd *, void *, long *, asymbol ***);
468 static const char *lookup_sym_redefinition (const char *);
470 static void
471 copy_usage (FILE *stream, int exit_status)
473 fprintf (stream, _("Usage: %s [option(s)] in-file [out-file]\n"), program_name);
474 fprintf (stream, _(" Copies a binary file, possibly transforming it in the process\n"));
475 fprintf (stream, _(" The options are:\n"));
476 fprintf (stream, _("\
477 -I --input-target <bfdname> Assume input file is in format <bfdname>\n\
478 -O --output-target <bfdname> Create an output file in format <bfdname>\n\
479 -B --binary-architecture <arch> Set output arch, when input is arch-less\n\
480 -F --target <bfdname> Set both input and output format to <bfdname>\n\
481 --debugging Convert debugging information, if possible\n\
482 -p --preserve-dates Copy modified/access timestamps to the output\n\
483 -j --only-section <name> Only copy section <name> into the output\n\
484 --add-gnu-debuglink=<file> Add section .gnu_debuglink linking to <file>\n\
485 -R --remove-section <name> Remove section <name> from the output\n\
486 -S --strip-all Remove all symbol and relocation information\n\
487 -g --strip-debug Remove all debugging symbols & sections\n\
488 --strip-unneeded Remove all symbols not needed by relocations\n\
489 -N --strip-symbol <name> Do not copy symbol <name>\n\
490 --strip-unneeded-symbol <name>\n\
491 Do not copy symbol <name> unless needed by\n\
492 relocations\n\
493 --only-keep-debug Strip everything but the debug information\n\
494 --extract-symbol Remove section contents but keep symbols\n\
495 -K --keep-symbol <name> Do not strip symbol <name>\n\
496 --keep-file-symbols Do not strip file symbol(s)\n\
497 --localize-hidden Turn all ELF hidden symbols into locals\n\
498 -L --localize-symbol <name> Force symbol <name> to be marked as a local\n\
499 --globalize-symbol <name> Force symbol <name> to be marked as a global\n\
500 -G --keep-global-symbol <name> Localize all symbols except <name>\n\
501 -W --weaken-symbol <name> Force symbol <name> to be marked as a weak\n\
502 --weaken Force all global symbols to be marked as weak\n\
503 -w --wildcard Permit wildcard in symbol comparison\n\
504 -x --discard-all Remove all non-global symbols\n\
505 -X --discard-locals Remove any compiler-generated symbols\n\
506 -i --interleave [<number>] Only copy N out of every <number> bytes\n\
507 --interleave-width <number> Set N for --interleave\n\
508 -b --byte <num> Select byte <num> in every interleaved block\n\
509 --gap-fill <val> Fill gaps between sections with <val>\n\
510 --pad-to <addr> Pad the last section up to address <addr>\n\
511 --set-start <addr> Set the start address to <addr>\n\
512 {--change-start|--adjust-start} <incr>\n\
513 Add <incr> to the start address\n\
514 {--change-addresses|--adjust-vma} <incr>\n\
515 Add <incr> to LMA, VMA and start addresses\n\
516 {--change-section-address|--adjust-section-vma} <name>{=|+|-}<val>\n\
517 Change LMA and VMA of section <name> by <val>\n\
518 --change-section-lma <name>{=|+|-}<val>\n\
519 Change the LMA of section <name> by <val>\n\
520 --change-section-vma <name>{=|+|-}<val>\n\
521 Change the VMA of section <name> by <val>\n\
522 {--[no-]change-warnings|--[no-]adjust-warnings}\n\
523 Warn if a named section does not exist\n\
524 --set-section-flags <name>=<flags>\n\
525 Set section <name>'s properties to <flags>\n\
526 --add-section <name>=<file> Add section <name> found in <file> to output\n\
527 --rename-section <old>=<new>[,<flags>] Rename section <old> to <new>\n\
528 --long-section-names {enable|disable|keep}\n\
529 Handle long section names in Coff objects.\n\
530 --change-leading-char Force output format's leading character style\n\
531 --remove-leading-char Remove leading character from global symbols\n\
532 --reverse-bytes=<num> Reverse <num> bytes at a time, in output sections with content\n\
533 --redefine-sym <old>=<new> Redefine symbol name <old> to <new>\n\
534 --redefine-syms <file> --redefine-sym for all symbol pairs \n\
535 listed in <file>\n\
536 --srec-len <number> Restrict the length of generated Srecords\n\
537 --srec-forceS3 Restrict the type of generated Srecords to S3\n\
538 --strip-symbols <file> -N for all symbols listed in <file>\n\
539 --strip-unneeded-symbols <file>\n\
540 --strip-unneeded-symbol for all symbols listed\n\
541 in <file>\n\
542 --keep-symbols <file> -K for all symbols listed in <file>\n\
543 --localize-symbols <file> -L for all symbols listed in <file>\n\
544 --globalize-symbols <file> --globalize-symbol for all in <file>\n\
545 --keep-global-symbols <file> -G for all symbols listed in <file>\n\
546 --weaken-symbols <file> -W for all symbols listed in <file>\n\
547 --alt-machine-code <index> Use the target's <index>'th alternative machine\n\
548 --writable-text Mark the output text as writable\n\
549 --readonly-text Make the output text write protected\n\
550 --pure Mark the output file as demand paged\n\
551 --impure Mark the output file as impure\n\
552 --prefix-symbols <prefix> Add <prefix> to start of every symbol name\n\
553 --prefix-sections <prefix> Add <prefix> to start of every section name\n\
554 --prefix-alloc-sections <prefix>\n\
555 Add <prefix> to start of every allocatable\n\
556 section name\n\
557 --file-alignment <num> Set PE file alignment to <num>\n\
558 --heap <reserve>[,<commit>] Set PE reserve/commit heap to <reserve>/\n\
559 <commit>\n\
560 --image-base <address> Set PE image base to <address>\n\
561 --section-alignment <num> Set PE section alignment to <num>\n\
562 --stack <reserve>[,<commit>] Set PE reserve/commit stack to <reserve>/\n\
563 <commit>\n\
564 --subsystem <name>[:<version>]\n\
565 Set PE subsystem to <name> [& <version>]\n\
566 --compress-debug-sections Compress DWARF debug sections using zlib\n\
567 --decompress-debug-sections Decompress DWARF debug sections using zlib\n\
568 -v --verbose List all object files modified\n\
569 @<file> Read options from <file>\n\
570 -V --version Display this program's version number\n\
571 -h --help Display this output\n\
572 --info List object formats & architectures supported\n\
573 "));
574 list_supported_targets (program_name, stream);
575 if (REPORT_BUGS_TO[0] && exit_status == 0)
576 fprintf (stream, _("Report bugs to %s\n"), REPORT_BUGS_TO);
577 exit (exit_status);
580 static void
581 strip_usage (FILE *stream, int exit_status)
583 fprintf (stream, _("Usage: %s <option(s)> in-file(s)\n"), program_name);
584 fprintf (stream, _(" Removes symbols and sections from files\n"));
585 fprintf (stream, _(" The options are:\n"));
586 fprintf (stream, _("\
587 -I --input-target=<bfdname> Assume input file is in format <bfdname>\n\
588 -O --output-target=<bfdname> Create an output file in format <bfdname>\n\
589 -F --target=<bfdname> Set both input and output format to <bfdname>\n\
590 -p --preserve-dates Copy modified/access timestamps to the output\n\
591 -R --remove-section=<name> Remove section <name> from the output\n\
592 -s --strip-all Remove all symbol and relocation information\n\
593 -g -S -d --strip-debug Remove all debugging symbols & sections\n\
594 --strip-unneeded Remove all symbols not needed by relocations\n\
595 --only-keep-debug Strip everything but the debug information\n\
596 -N --strip-symbol=<name> Do not copy symbol <name>\n\
597 -K --keep-symbol=<name> Do not strip symbol <name>\n\
598 --keep-file-symbols Do not strip file symbol(s)\n\
599 -w --wildcard Permit wildcard in symbol comparison\n\
600 -x --discard-all Remove all non-global symbols\n\
601 -X --discard-locals Remove any compiler-generated symbols\n\
602 -v --verbose List all object files modified\n\
603 -V --version Display this program's version number\n\
604 -h --help Display this output\n\
605 --info List object formats & architectures supported\n\
606 -o <file> Place stripped output into <file>\n\
607 "));
609 list_supported_targets (program_name, stream);
610 if (REPORT_BUGS_TO[0] && exit_status == 0)
611 fprintf (stream, _("Report bugs to %s\n"), REPORT_BUGS_TO);
612 exit (exit_status);
615 /* Parse section flags into a flagword, with a fatal error if the
616 string can't be parsed. */
618 static flagword
619 parse_flags (const char *s)
621 flagword ret;
622 const char *snext;
623 int len;
625 ret = SEC_NO_FLAGS;
629 snext = strchr (s, ',');
630 if (snext == NULL)
631 len = strlen (s);
632 else
634 len = snext - s;
635 ++snext;
638 if (0) ;
639 #define PARSE_FLAG(fname,fval) \
640 else if (strncasecmp (fname, s, len) == 0) ret |= fval
641 PARSE_FLAG ("alloc", SEC_ALLOC);
642 PARSE_FLAG ("load", SEC_LOAD);
643 PARSE_FLAG ("noload", SEC_NEVER_LOAD);
644 PARSE_FLAG ("readonly", SEC_READONLY);
645 PARSE_FLAG ("debug", SEC_DEBUGGING);
646 PARSE_FLAG ("code", SEC_CODE);
647 PARSE_FLAG ("data", SEC_DATA);
648 PARSE_FLAG ("rom", SEC_ROM);
649 PARSE_FLAG ("share", SEC_COFF_SHARED);
650 PARSE_FLAG ("contents", SEC_HAS_CONTENTS);
651 #undef PARSE_FLAG
652 else
654 char *copy;
656 copy = (char *) xmalloc (len + 1);
657 strncpy (copy, s, len);
658 copy[len] = '\0';
659 non_fatal (_("unrecognized section flag `%s'"), copy);
660 fatal (_("supported flags: %s"),
661 "alloc, load, noload, readonly, debug, code, data, rom, share, contents");
664 s = snext;
666 while (s != NULL);
668 return ret;
671 /* Find and optionally add an entry in the change_sections list. */
673 static struct section_list *
674 find_section_list (const char *name, bfd_boolean add)
676 struct section_list *p;
678 for (p = change_sections; p != NULL; p = p->next)
679 if (strcmp (p->name, name) == 0)
680 return p;
682 if (! add)
683 return NULL;
685 p = (struct section_list *) xmalloc (sizeof (struct section_list));
686 p->name = name;
687 p->used = FALSE;
688 p->remove = FALSE;
689 p->copy = FALSE;
690 p->change_vma = CHANGE_IGNORE;
691 p->change_lma = CHANGE_IGNORE;
692 p->vma_val = 0;
693 p->lma_val = 0;
694 p->set_flags = FALSE;
695 p->flags = 0;
697 p->next = change_sections;
698 change_sections = p;
700 return p;
703 /* There is htab_hash_string but no htab_eq_string. Makes sense. */
705 static int
706 eq_string (const void *s1, const void *s2)
708 return strcmp ((const char *) s1, (const char *) s2) == 0;
711 static htab_t
712 create_symbol_htab (void)
714 return htab_create_alloc (16, htab_hash_string, eq_string, NULL, xcalloc, free);
717 static void
718 create_symbol_htabs (void)
720 strip_specific_htab = create_symbol_htab ();
721 strip_unneeded_htab = create_symbol_htab ();
722 keep_specific_htab = create_symbol_htab ();
723 localize_specific_htab = create_symbol_htab ();
724 globalize_specific_htab = create_symbol_htab ();
725 keepglobal_specific_htab = create_symbol_htab ();
726 weaken_specific_htab = create_symbol_htab ();
729 /* Add a symbol to strip_specific_list. */
731 static void
732 add_specific_symbol (const char *name, htab_t htab)
734 *htab_find_slot (htab, name, INSERT) = (char *) name;
737 /* Add symbols listed in `filename' to strip_specific_list. */
739 #define IS_WHITESPACE(c) ((c) == ' ' || (c) == '\t')
740 #define IS_LINE_TERMINATOR(c) ((c) == '\n' || (c) == '\r' || (c) == '\0')
742 static void
743 add_specific_symbols (const char *filename, htab_t htab)
745 off_t size;
746 FILE * f;
747 char * line;
748 char * buffer;
749 unsigned int line_count;
751 size = get_file_size (filename);
752 if (size == 0)
754 status = 1;
755 return;
758 buffer = (char *) xmalloc (size + 2);
759 f = fopen (filename, FOPEN_RT);
760 if (f == NULL)
761 fatal (_("cannot open '%s': %s"), filename, strerror (errno));
763 if (fread (buffer, 1, size, f) == 0 || ferror (f))
764 fatal (_("%s: fread failed"), filename);
766 fclose (f);
767 buffer [size] = '\n';
768 buffer [size + 1] = '\0';
770 line_count = 1;
772 for (line = buffer; * line != '\0'; line ++)
774 char * eol;
775 char * name;
776 char * name_end;
777 int finished = FALSE;
779 for (eol = line;; eol ++)
781 switch (* eol)
783 case '\n':
784 * eol = '\0';
785 /* Cope with \n\r. */
786 if (eol[1] == '\r')
787 ++ eol;
788 finished = TRUE;
789 break;
791 case '\r':
792 * eol = '\0';
793 /* Cope with \r\n. */
794 if (eol[1] == '\n')
795 ++ eol;
796 finished = TRUE;
797 break;
799 case 0:
800 finished = TRUE;
801 break;
803 case '#':
804 /* Line comment, Terminate the line here, in case a
805 name is present and then allow the rest of the
806 loop to find the real end of the line. */
807 * eol = '\0';
808 break;
810 default:
811 break;
814 if (finished)
815 break;
818 /* A name may now exist somewhere between 'line' and 'eol'.
819 Strip off leading whitespace and trailing whitespace,
820 then add it to the list. */
821 for (name = line; IS_WHITESPACE (* name); name ++)
823 for (name_end = name;
824 (! IS_WHITESPACE (* name_end))
825 && (! IS_LINE_TERMINATOR (* name_end));
826 name_end ++)
829 if (! IS_LINE_TERMINATOR (* name_end))
831 char * extra;
833 for (extra = name_end + 1; IS_WHITESPACE (* extra); extra ++)
836 if (! IS_LINE_TERMINATOR (* extra))
837 non_fatal (_("%s:%d: Ignoring rubbish found on this line"),
838 filename, line_count);
841 * name_end = '\0';
843 if (name_end > name)
844 add_specific_symbol (name, htab);
846 /* Advance line pointer to end of line. The 'eol ++' in the for
847 loop above will then advance us to the start of the next line. */
848 line = eol;
849 line_count ++;
853 /* See whether a symbol should be stripped or kept
854 based on strip_specific_list and keep_symbols. */
856 static int
857 is_specified_symbol_predicate (void **slot, void *data)
859 struct is_specified_symbol_predicate_data *d =
860 (struct is_specified_symbol_predicate_data *) data;
861 const char *slot_name = (char *) *slot;
863 if (*slot_name != '!')
865 if (! fnmatch (slot_name, d->name, 0))
867 d->found = TRUE;
868 /* Stop traversal. */
869 return 0;
872 else
874 if (fnmatch (slot_name + 1, d->name, 0))
876 d->found = TRUE;
877 /* Stop traversal. */
878 return 0;
882 /* Continue traversal. */
883 return 1;
886 static bfd_boolean
887 is_specified_symbol (const char *name, htab_t htab)
889 if (wildcard)
891 struct is_specified_symbol_predicate_data data;
893 data.name = name;
894 data.found = FALSE;
896 htab_traverse (htab, is_specified_symbol_predicate, &data);
898 return data.found;
901 return htab_find (htab, name) != NULL;
904 /* Return a pointer to the symbol used as a signature for GROUP. */
906 static asymbol *
907 group_signature (asection *group)
909 bfd *abfd = group->owner;
910 Elf_Internal_Shdr *ghdr;
912 if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
913 return NULL;
915 ghdr = &elf_section_data (group)->this_hdr;
916 if (ghdr->sh_link < elf_numsections (abfd))
918 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
919 Elf_Internal_Shdr *symhdr = elf_elfsections (abfd) [ghdr->sh_link];
921 if (symhdr->sh_type == SHT_SYMTAB
922 && ghdr->sh_info < symhdr->sh_size / bed->s->sizeof_sym)
923 return isympp[ghdr->sh_info - 1];
925 return NULL;
928 /* See if a section is being removed. */
930 static bfd_boolean
931 is_strip_section (bfd *abfd ATTRIBUTE_UNUSED, asection *sec)
933 if (sections_removed || sections_copied)
935 struct section_list *p;
937 p = find_section_list (bfd_get_section_name (abfd, sec), FALSE);
939 if (sections_removed && p != NULL && p->remove)
940 return TRUE;
941 if (sections_copied && (p == NULL || ! p->copy))
942 return TRUE;
945 if ((bfd_get_section_flags (abfd, sec) & SEC_DEBUGGING) != 0)
947 if (strip_symbols == STRIP_DEBUG
948 || strip_symbols == STRIP_UNNEEDED
949 || strip_symbols == STRIP_ALL
950 || discard_locals == LOCALS_ALL
951 || convert_debugging)
952 return TRUE;
954 if (strip_symbols == STRIP_NONDEBUG)
955 return FALSE;
958 if ((bfd_get_section_flags (abfd, sec) & SEC_GROUP) != 0)
960 asymbol *gsym;
961 const char *gname;
963 /* PR binutils/3181
964 If we are going to strip the group signature symbol, then
965 strip the group section too. */
966 gsym = group_signature (sec);
967 if (gsym != NULL)
968 gname = gsym->name;
969 else
970 gname = sec->name;
971 if ((strip_symbols == STRIP_ALL
972 && !is_specified_symbol (gname, keep_specific_htab))
973 || is_specified_symbol (gname, strip_specific_htab))
974 return TRUE;
977 return FALSE;
980 /* Return true if SYM is a hidden symbol. */
982 static bfd_boolean
983 is_hidden_symbol (asymbol *sym)
985 elf_symbol_type *elf_sym;
987 elf_sym = elf_symbol_from (sym->the_bfd, sym);
988 if (elf_sym != NULL)
989 switch (ELF_ST_VISIBILITY (elf_sym->internal_elf_sym.st_other))
991 case STV_HIDDEN:
992 case STV_INTERNAL:
993 return TRUE;
995 return FALSE;
998 /* Choose which symbol entries to copy; put the result in OSYMS.
999 We don't copy in place, because that confuses the relocs.
1000 Return the number of symbols to print. */
1002 static unsigned int
1003 filter_symbols (bfd *abfd, bfd *obfd, asymbol **osyms,
1004 asymbol **isyms, long symcount)
1006 asymbol **from = isyms, **to = osyms;
1007 long src_count = 0, dst_count = 0;
1008 int relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
1010 for (; src_count < symcount; src_count++)
1012 asymbol *sym = from[src_count];
1013 flagword flags = sym->flags;
1014 char *name = (char *) bfd_asymbol_name (sym);
1015 bfd_boolean keep;
1016 bfd_boolean used_in_reloc = FALSE;
1017 bfd_boolean undefined;
1018 bfd_boolean rem_leading_char;
1019 bfd_boolean add_leading_char;
1021 undefined = bfd_is_und_section (bfd_get_section (sym));
1023 if (redefine_sym_list)
1025 char *old_name, *new_name;
1027 old_name = (char *) bfd_asymbol_name (sym);
1028 new_name = (char *) lookup_sym_redefinition (old_name);
1029 bfd_asymbol_name (sym) = new_name;
1030 name = new_name;
1033 /* Check if we will remove the current leading character. */
1034 rem_leading_char =
1035 (name[0] == bfd_get_symbol_leading_char (abfd))
1036 && (change_leading_char
1037 || (remove_leading_char
1038 && ((flags & (BSF_GLOBAL | BSF_WEAK)) != 0
1039 || undefined
1040 || bfd_is_com_section (bfd_get_section (sym)))));
1042 /* Check if we will add a new leading character. */
1043 add_leading_char =
1044 change_leading_char
1045 && (bfd_get_symbol_leading_char (obfd) != '\0')
1046 && (bfd_get_symbol_leading_char (abfd) == '\0'
1047 || (name[0] == bfd_get_symbol_leading_char (abfd)));
1049 /* Short circuit for change_leading_char if we can do it in-place. */
1050 if (rem_leading_char && add_leading_char && !prefix_symbols_string)
1052 name[0] = bfd_get_symbol_leading_char (obfd);
1053 bfd_asymbol_name (sym) = name;
1054 rem_leading_char = FALSE;
1055 add_leading_char = FALSE;
1058 /* Remove leading char. */
1059 if (rem_leading_char)
1060 bfd_asymbol_name (sym) = ++name;
1062 /* Add new leading char and/or prefix. */
1063 if (add_leading_char || prefix_symbols_string)
1065 char *n, *ptr;
1067 ptr = n = (char *) xmalloc (1 + strlen (prefix_symbols_string)
1068 + strlen (name) + 1);
1069 if (add_leading_char)
1070 *ptr++ = bfd_get_symbol_leading_char (obfd);
1072 if (prefix_symbols_string)
1074 strcpy (ptr, prefix_symbols_string);
1075 ptr += strlen (prefix_symbols_string);
1078 strcpy (ptr, name);
1079 bfd_asymbol_name (sym) = n;
1080 name = n;
1083 if (strip_symbols == STRIP_ALL)
1084 keep = FALSE;
1085 else if ((flags & BSF_KEEP) != 0 /* Used in relocation. */
1086 || ((flags & BSF_SECTION_SYM) != 0
1087 && ((*bfd_get_section (sym)->symbol_ptr_ptr)->flags
1088 & BSF_KEEP) != 0))
1090 keep = TRUE;
1091 used_in_reloc = TRUE;
1093 else if (relocatable /* Relocatable file. */
1094 && ((flags & (BSF_GLOBAL | BSF_WEAK)) != 0
1095 || bfd_is_com_section (bfd_get_section (sym))))
1096 keep = TRUE;
1097 else if (bfd_decode_symclass (sym) == 'I')
1098 /* Global symbols in $idata sections need to be retained
1099 even if relocatable is FALSE. External users of the
1100 library containing the $idata section may reference these
1101 symbols. */
1102 keep = TRUE;
1103 else if ((flags & BSF_GLOBAL) != 0 /* Global symbol. */
1104 || (flags & BSF_WEAK) != 0
1105 || undefined
1106 || bfd_is_com_section (bfd_get_section (sym)))
1107 keep = strip_symbols != STRIP_UNNEEDED;
1108 else if ((flags & BSF_DEBUGGING) != 0) /* Debugging symbol. */
1109 keep = (strip_symbols != STRIP_DEBUG
1110 && strip_symbols != STRIP_UNNEEDED
1111 && ! convert_debugging);
1112 else if (bfd_coff_get_comdat_section (abfd, bfd_get_section (sym)))
1113 /* COMDAT sections store special information in local
1114 symbols, so we cannot risk stripping any of them. */
1115 keep = TRUE;
1116 else /* Local symbol. */
1117 keep = (strip_symbols != STRIP_UNNEEDED
1118 && (discard_locals != LOCALS_ALL
1119 && (discard_locals != LOCALS_START_L
1120 || ! bfd_is_local_label (abfd, sym))));
1122 if (keep && is_specified_symbol (name, strip_specific_htab))
1124 /* There are multiple ways to set 'keep' above, but if it
1125 was the relocatable symbol case, then that's an error. */
1126 if (used_in_reloc)
1128 non_fatal (_("not stripping symbol `%s' because it is named in a relocation"), name);
1129 status = 1;
1131 else
1132 keep = FALSE;
1135 if (keep
1136 && !(flags & BSF_KEEP)
1137 && is_specified_symbol (name, strip_unneeded_htab))
1138 keep = FALSE;
1140 if (!keep
1141 && ((keep_file_symbols && (flags & BSF_FILE))
1142 || is_specified_symbol (name, keep_specific_htab)))
1143 keep = TRUE;
1145 if (keep && is_strip_section (abfd, bfd_get_section (sym)))
1146 keep = FALSE;
1148 if (keep)
1150 if ((flags & BSF_GLOBAL) != 0
1151 && (weaken || is_specified_symbol (name, weaken_specific_htab)))
1153 sym->flags &= ~ BSF_GLOBAL;
1154 sym->flags |= BSF_WEAK;
1157 if (!undefined
1158 && (flags & (BSF_GLOBAL | BSF_WEAK))
1159 && (is_specified_symbol (name, localize_specific_htab)
1160 || (htab_elements (keepglobal_specific_htab) != 0
1161 && ! is_specified_symbol (name, keepglobal_specific_htab))
1162 || (localize_hidden && is_hidden_symbol (sym))))
1164 sym->flags &= ~ (BSF_GLOBAL | BSF_WEAK);
1165 sym->flags |= BSF_LOCAL;
1168 if (!undefined
1169 && (flags & BSF_LOCAL)
1170 && is_specified_symbol (name, globalize_specific_htab))
1172 sym->flags &= ~ BSF_LOCAL;
1173 sym->flags |= BSF_GLOBAL;
1176 to[dst_count++] = sym;
1180 to[dst_count] = NULL;
1182 return dst_count;
1185 /* Find the redefined name of symbol SOURCE. */
1187 static const char *
1188 lookup_sym_redefinition (const char *source)
1190 struct redefine_node *list;
1192 for (list = redefine_sym_list; list != NULL; list = list->next)
1193 if (strcmp (source, list->source) == 0)
1194 return list->target;
1196 return source;
1199 /* Add a node to a symbol redefine list. */
1201 static void
1202 redefine_list_append (const char *cause, const char *source, const char *target)
1204 struct redefine_node **p;
1205 struct redefine_node *list;
1206 struct redefine_node *new_node;
1208 for (p = &redefine_sym_list; (list = *p) != NULL; p = &list->next)
1210 if (strcmp (source, list->source) == 0)
1211 fatal (_("%s: Multiple redefinition of symbol \"%s\""),
1212 cause, source);
1214 if (strcmp (target, list->target) == 0)
1215 fatal (_("%s: Symbol \"%s\" is target of more than one redefinition"),
1216 cause, target);
1219 new_node = (struct redefine_node *) xmalloc (sizeof (struct redefine_node));
1221 new_node->source = strdup (source);
1222 new_node->target = strdup (target);
1223 new_node->next = NULL;
1225 *p = new_node;
1228 /* Handle the --redefine-syms option. Read lines containing "old new"
1229 from the file, and add them to the symbol redefine list. */
1231 static void
1232 add_redefine_syms_file (const char *filename)
1234 FILE *file;
1235 char *buf;
1236 size_t bufsize;
1237 size_t len;
1238 size_t outsym_off;
1239 int c, lineno;
1241 file = fopen (filename, "r");
1242 if (file == NULL)
1243 fatal (_("couldn't open symbol redefinition file %s (error: %s)"),
1244 filename, strerror (errno));
1246 bufsize = 100;
1247 buf = (char *) xmalloc (bufsize + 1 /* For the terminating NUL. */);
1249 lineno = 1;
1250 c = getc (file);
1251 len = 0;
1252 outsym_off = 0;
1253 while (c != EOF)
1255 /* Collect the input symbol name. */
1256 while (! IS_WHITESPACE (c) && ! IS_LINE_TERMINATOR (c) && c != EOF)
1258 if (c == '#')
1259 goto comment;
1260 buf[len++] = c;
1261 if (len >= bufsize)
1263 bufsize *= 2;
1264 buf = (char *) xrealloc (buf, bufsize + 1);
1266 c = getc (file);
1268 buf[len++] = '\0';
1269 if (c == EOF)
1270 break;
1272 /* Eat white space between the symbol names. */
1273 while (IS_WHITESPACE (c))
1274 c = getc (file);
1275 if (c == '#' || IS_LINE_TERMINATOR (c))
1276 goto comment;
1277 if (c == EOF)
1278 break;
1280 /* Collect the output symbol name. */
1281 outsym_off = len;
1282 while (! IS_WHITESPACE (c) && ! IS_LINE_TERMINATOR (c) && c != EOF)
1284 if (c == '#')
1285 goto comment;
1286 buf[len++] = c;
1287 if (len >= bufsize)
1289 bufsize *= 2;
1290 buf = (char *) xrealloc (buf, bufsize + 1);
1292 c = getc (file);
1294 buf[len++] = '\0';
1295 if (c == EOF)
1296 break;
1298 /* Eat white space at end of line. */
1299 while (! IS_LINE_TERMINATOR(c) && c != EOF && IS_WHITESPACE (c))
1300 c = getc (file);
1301 if (c == '#')
1302 goto comment;
1303 /* Handle \r\n. */
1304 if ((c == '\r' && (c = getc (file)) == '\n')
1305 || c == '\n' || c == EOF)
1307 end_of_line:
1308 /* Append the redefinition to the list. */
1309 if (buf[0] != '\0')
1310 redefine_list_append (filename, &buf[0], &buf[outsym_off]);
1312 lineno++;
1313 len = 0;
1314 outsym_off = 0;
1315 if (c == EOF)
1316 break;
1317 c = getc (file);
1318 continue;
1320 else
1321 fatal (_("%s:%d: garbage found at end of line"), filename, lineno);
1322 comment:
1323 if (len != 0 && (outsym_off == 0 || outsym_off == len))
1324 fatal (_("%s:%d: missing new symbol name"), filename, lineno);
1325 buf[len++] = '\0';
1327 /* Eat the rest of the line and finish it. */
1328 while (c != '\n' && c != EOF)
1329 c = getc (file);
1330 goto end_of_line;
1333 if (len != 0)
1334 fatal (_("%s:%d: premature end of file"), filename, lineno);
1336 free (buf);
1339 /* Copy unkown object file IBFD onto OBFD.
1340 Returns TRUE upon success, FALSE otherwise. */
1342 static bfd_boolean
1343 copy_unknown_object (bfd *ibfd, bfd *obfd)
1345 char *cbuf;
1346 int tocopy;
1347 long ncopied;
1348 long size;
1349 struct stat buf;
1351 if (bfd_stat_arch_elt (ibfd, &buf) != 0)
1353 bfd_nonfatal_message (NULL, ibfd, NULL, NULL);
1354 return FALSE;
1357 size = buf.st_size;
1358 if (size < 0)
1360 non_fatal (_("stat returns negative size for `%s'"),
1361 bfd_get_archive_filename (ibfd));
1362 return FALSE;
1365 if (bfd_seek (ibfd, (file_ptr) 0, SEEK_SET) != 0)
1367 bfd_nonfatal (bfd_get_archive_filename (ibfd));
1368 return FALSE;
1371 if (verbose)
1372 printf (_("copy from `%s' [unknown] to `%s' [unknown]\n"),
1373 bfd_get_archive_filename (ibfd), bfd_get_filename (obfd));
1375 cbuf = (char *) xmalloc (BUFSIZE);
1376 ncopied = 0;
1377 while (ncopied < size)
1379 tocopy = size - ncopied;
1380 if (tocopy > BUFSIZE)
1381 tocopy = BUFSIZE;
1383 if (bfd_bread (cbuf, (bfd_size_type) tocopy, ibfd)
1384 != (bfd_size_type) tocopy)
1386 bfd_nonfatal_message (NULL, ibfd, NULL, NULL);
1387 free (cbuf);
1388 return FALSE;
1391 if (bfd_bwrite (cbuf, (bfd_size_type) tocopy, obfd)
1392 != (bfd_size_type) tocopy)
1394 bfd_nonfatal_message (NULL, obfd, NULL, NULL);
1395 free (cbuf);
1396 return FALSE;
1399 ncopied += tocopy;
1402 /* We should at least to be able to read it back when copying an
1403 unknown object in an archive. */
1404 chmod (bfd_get_filename (obfd), buf.st_mode | S_IRUSR);
1405 free (cbuf);
1406 return TRUE;
1409 /* Copy object file IBFD onto OBFD.
1410 Returns TRUE upon success, FALSE otherwise. */
1412 static bfd_boolean
1413 copy_object (bfd *ibfd, bfd *obfd, const bfd_arch_info_type *input_arch)
1415 bfd_vma start;
1416 long symcount;
1417 asection **osections = NULL;
1418 asection *gnu_debuglink_section = NULL;
1419 bfd_size_type *gaps = NULL;
1420 bfd_size_type max_gap = 0;
1421 long symsize;
1422 void *dhandle;
1423 enum bfd_architecture iarch;
1424 unsigned int imach;
1426 if (ibfd->xvec->byteorder != obfd->xvec->byteorder
1427 && ibfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN
1428 && obfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN)
1429 fatal (_("Unable to change endianness of input file(s)"));
1431 if (!bfd_set_format (obfd, bfd_get_format (ibfd)))
1433 bfd_nonfatal_message (NULL, obfd, NULL, NULL);
1434 return FALSE;
1437 if (verbose)
1438 printf (_("copy from `%s' [%s] to `%s' [%s]\n"),
1439 bfd_get_archive_filename (ibfd), bfd_get_target (ibfd),
1440 bfd_get_filename (obfd), bfd_get_target (obfd));
1442 if (extract_symbol)
1443 start = 0;
1444 else
1446 if (set_start_set)
1447 start = set_start;
1448 else
1449 start = bfd_get_start_address (ibfd);
1450 start += change_start;
1453 /* Neither the start address nor the flags
1454 need to be set for a core file. */
1455 if (bfd_get_format (obfd) != bfd_core)
1457 flagword flags;
1459 flags = bfd_get_file_flags (ibfd);
1460 flags |= bfd_flags_to_set;
1461 flags &= ~bfd_flags_to_clear;
1462 flags &= bfd_applicable_file_flags (obfd);
1464 if (strip_symbols == STRIP_ALL)
1465 flags &= ~HAS_RELOC;
1467 if (!bfd_set_start_address (obfd, start)
1468 || !bfd_set_file_flags (obfd, flags))
1470 bfd_nonfatal_message (NULL, ibfd, NULL, NULL);
1471 return FALSE;
1475 /* Copy architecture of input file to output file. */
1476 iarch = bfd_get_arch (ibfd);
1477 imach = bfd_get_mach (ibfd);
1478 if (input_arch)
1480 if (bfd_get_arch_info (ibfd) == NULL
1481 || bfd_get_arch_info (ibfd)->arch == bfd_arch_unknown)
1483 iarch = input_arch->arch;
1484 imach = input_arch->mach;
1486 else
1487 non_fatal (_("Input file `%s' ignores binary architecture parameter."),
1488 bfd_get_archive_filename (ibfd));
1490 if (!bfd_set_arch_mach (obfd, iarch, imach)
1491 && (ibfd->target_defaulted
1492 || bfd_get_arch (ibfd) != bfd_get_arch (obfd)))
1494 if (bfd_get_arch (ibfd) == bfd_arch_unknown)
1495 non_fatal (_("Unable to recognise the format of the input file `%s'"),
1496 bfd_get_archive_filename (ibfd));
1497 else
1498 non_fatal (_("Output file cannot represent architecture `%s'"),
1499 bfd_printable_arch_mach (bfd_get_arch (ibfd),
1500 bfd_get_mach (ibfd)));
1501 return FALSE;
1504 if (!bfd_set_format (obfd, bfd_get_format (ibfd)))
1506 bfd_nonfatal_message (NULL, ibfd, NULL, NULL);
1507 return FALSE;
1510 if (bfd_get_flavour (obfd) == bfd_target_coff_flavour
1511 && bfd_pei_p (obfd))
1513 /* Set up PE parameters. */
1514 pe_data_type *pe = pe_data (obfd);
1516 /* Copy PE parameters before changing them. */
1517 if (ibfd->xvec->flavour == bfd_target_coff_flavour
1518 && bfd_pei_p (ibfd))
1519 pe->pe_opthdr = pe_data (ibfd)->pe_opthdr;
1521 if (pe_file_alignment != (bfd_vma) -1)
1522 pe->pe_opthdr.FileAlignment = pe_file_alignment;
1523 else
1524 pe_file_alignment = PE_DEF_FILE_ALIGNMENT;
1526 if (pe_heap_commit != (bfd_vma) -1)
1527 pe->pe_opthdr.SizeOfHeapCommit = pe_heap_commit;
1529 if (pe_heap_reserve != (bfd_vma) -1)
1530 pe->pe_opthdr.SizeOfHeapCommit = pe_heap_reserve;
1532 if (pe_image_base != (bfd_vma) -1)
1533 pe->pe_opthdr.ImageBase = pe_image_base;
1535 if (pe_section_alignment != (bfd_vma) -1)
1536 pe->pe_opthdr.SectionAlignment = pe_section_alignment;
1537 else
1538 pe_section_alignment = PE_DEF_SECTION_ALIGNMENT;
1540 if (pe_stack_commit != (bfd_vma) -1)
1541 pe->pe_opthdr.SizeOfStackCommit = pe_stack_commit;
1543 if (pe_stack_reserve != (bfd_vma) -1)
1544 pe->pe_opthdr.SizeOfStackCommit = pe_stack_reserve;
1546 if (pe_subsystem != -1)
1547 pe->pe_opthdr.Subsystem = pe_subsystem;
1549 if (pe_major_subsystem_version != -1)
1550 pe->pe_opthdr.MajorSubsystemVersion = pe_major_subsystem_version;
1552 if (pe_minor_subsystem_version != -1)
1553 pe->pe_opthdr.MinorSubsystemVersion = pe_minor_subsystem_version;
1555 if (pe_file_alignment > pe_section_alignment)
1557 char file_alignment[20], section_alignment[20];
1559 sprintf_vma (file_alignment, pe_file_alignment);
1560 sprintf_vma (section_alignment, pe_section_alignment);
1561 non_fatal (_("warning: file alignment (0x%s) > section alignment (0x%s)"),
1563 file_alignment, section_alignment);
1567 if (isympp)
1568 free (isympp);
1570 if (osympp != isympp)
1571 free (osympp);
1573 isympp = NULL;
1574 osympp = NULL;
1576 symsize = bfd_get_symtab_upper_bound (ibfd);
1577 if (symsize < 0)
1579 bfd_nonfatal_message (NULL, ibfd, NULL, NULL);
1580 return FALSE;
1583 osympp = isympp = (asymbol **) xmalloc (symsize);
1584 symcount = bfd_canonicalize_symtab (ibfd, isympp);
1585 if (symcount < 0)
1587 bfd_nonfatal_message (NULL, ibfd, NULL, NULL);
1588 return FALSE;
1591 /* BFD mandates that all output sections be created and sizes set before
1592 any output is done. Thus, we traverse all sections multiple times. */
1593 bfd_map_over_sections (ibfd, setup_section, obfd);
1595 if (!extract_symbol)
1596 setup_bfd_headers (ibfd, obfd);
1598 if (add_sections != NULL)
1600 struct section_add *padd;
1601 struct section_list *pset;
1603 for (padd = add_sections; padd != NULL; padd = padd->next)
1605 flagword flags;
1607 pset = find_section_list (padd->name, FALSE);
1608 if (pset != NULL)
1609 pset->used = TRUE;
1611 flags = SEC_HAS_CONTENTS | SEC_READONLY | SEC_DATA;
1612 if (pset != NULL && pset->set_flags)
1613 flags = pset->flags | SEC_HAS_CONTENTS;
1615 /* bfd_make_section_with_flags() does not return very helpful
1616 error codes, so check for the most likely user error first. */
1617 if (bfd_get_section_by_name (obfd, padd->name))
1619 bfd_nonfatal_message (NULL, obfd, NULL,
1620 _("can't add section '%s'"), padd->name);
1621 return FALSE;
1623 else
1625 /* We use LINKER_CREATED here so that the backend hooks
1626 will create any special section type information,
1627 instead of presuming we know what we're doing merely
1628 because we set the flags. */
1629 padd->section = bfd_make_section_with_flags
1630 (obfd, padd->name, flags | SEC_LINKER_CREATED);
1631 if (padd->section == NULL)
1633 bfd_nonfatal_message (NULL, obfd, NULL,
1634 _("can't create section `%s'"),
1635 padd->name);
1636 return FALSE;
1640 if (! bfd_set_section_size (obfd, padd->section, padd->size))
1642 bfd_nonfatal_message (NULL, obfd, padd->section, NULL);
1643 return FALSE;
1646 if (pset != NULL)
1648 if (pset->change_vma != CHANGE_IGNORE)
1649 if (! bfd_set_section_vma (obfd, padd->section,
1650 pset->vma_val))
1652 bfd_nonfatal_message (NULL, obfd, padd->section, NULL);
1653 return FALSE;
1656 if (pset->change_lma != CHANGE_IGNORE)
1658 padd->section->lma = pset->lma_val;
1660 if (! bfd_set_section_alignment
1661 (obfd, padd->section,
1662 bfd_section_alignment (obfd, padd->section)))
1664 bfd_nonfatal_message (NULL, obfd, padd->section, NULL);
1665 return FALSE;
1672 if (gnu_debuglink_filename != NULL)
1674 gnu_debuglink_section = bfd_create_gnu_debuglink_section
1675 (obfd, gnu_debuglink_filename);
1677 if (gnu_debuglink_section == NULL)
1679 bfd_nonfatal_message (NULL, obfd, NULL,
1680 _("cannot create debug link section `%s'"),
1681 gnu_debuglink_filename);
1682 return FALSE;
1685 /* Special processing for PE format files. We
1686 have no way to distinguish PE from COFF here. */
1687 if (bfd_get_flavour (obfd) == bfd_target_coff_flavour)
1689 bfd_vma debuglink_vma;
1690 asection * highest_section;
1691 asection * sec;
1693 /* The PE spec requires that all sections be adjacent and sorted
1694 in ascending order of VMA. It also specifies that debug
1695 sections should be last. This is despite the fact that debug
1696 sections are not loaded into memory and so in theory have no
1697 use for a VMA.
1699 This means that the debuglink section must be given a non-zero
1700 VMA which makes it contiguous with other debug sections. So
1701 walk the current section list, find the section with the
1702 highest VMA and start the debuglink section after that one. */
1703 for (sec = obfd->sections, highest_section = NULL;
1704 sec != NULL;
1705 sec = sec->next)
1706 if (sec->vma > 0
1707 && (highest_section == NULL
1708 || sec->vma > highest_section->vma))
1709 highest_section = sec;
1711 if (highest_section)
1712 debuglink_vma = BFD_ALIGN (highest_section->vma
1713 + highest_section->size,
1714 /* FIXME: We ought to be using
1715 COFF_PAGE_SIZE here or maybe
1716 bfd_get_section_alignment() (if it
1717 was set) but since this is for PE
1718 and we know the required alignment
1719 it is easier just to hard code it. */
1720 0x1000);
1721 else
1722 /* Umm, not sure what to do in this case. */
1723 debuglink_vma = 0x1000;
1725 bfd_set_section_vma (obfd, gnu_debuglink_section, debuglink_vma);
1729 if (bfd_count_sections (obfd) != 0
1730 && (gap_fill_set || pad_to_set))
1732 asection **set;
1733 unsigned int c, i;
1735 /* We must fill in gaps between the sections and/or we must pad
1736 the last section to a specified address. We do this by
1737 grabbing a list of the sections, sorting them by VMA, and
1738 increasing the section sizes as required to fill the gaps.
1739 We write out the gap contents below. */
1741 c = bfd_count_sections (obfd);
1742 osections = (asection **) xmalloc (c * sizeof (asection *));
1743 set = osections;
1744 bfd_map_over_sections (obfd, get_sections, &set);
1746 qsort (osections, c, sizeof (asection *), compare_section_lma);
1748 gaps = (bfd_size_type *) xmalloc (c * sizeof (bfd_size_type));
1749 memset (gaps, 0, c * sizeof (bfd_size_type));
1751 if (gap_fill_set)
1753 for (i = 0; i < c - 1; i++)
1755 flagword flags;
1756 bfd_size_type size;
1757 bfd_vma gap_start, gap_stop;
1759 flags = bfd_get_section_flags (obfd, osections[i]);
1760 if ((flags & SEC_HAS_CONTENTS) == 0
1761 || (flags & SEC_LOAD) == 0)
1762 continue;
1764 size = bfd_section_size (obfd, osections[i]);
1765 gap_start = bfd_section_lma (obfd, osections[i]) + size;
1766 gap_stop = bfd_section_lma (obfd, osections[i + 1]);
1767 if (gap_start < gap_stop)
1769 if (! bfd_set_section_size (obfd, osections[i],
1770 size + (gap_stop - gap_start)))
1772 bfd_nonfatal_message (NULL, obfd, osections[i],
1773 _("Can't fill gap after section"));
1774 status = 1;
1775 break;
1777 gaps[i] = gap_stop - gap_start;
1778 if (max_gap < gap_stop - gap_start)
1779 max_gap = gap_stop - gap_start;
1784 if (pad_to_set)
1786 bfd_vma lma;
1787 bfd_size_type size;
1789 lma = bfd_section_lma (obfd, osections[c - 1]);
1790 size = bfd_section_size (obfd, osections[c - 1]);
1791 if (lma + size < pad_to)
1793 if (! bfd_set_section_size (obfd, osections[c - 1],
1794 pad_to - lma))
1796 bfd_nonfatal_message (NULL, obfd, osections[c - 1],
1797 _("can't add padding"));
1798 status = 1;
1800 else
1802 gaps[c - 1] = pad_to - (lma + size);
1803 if (max_gap < pad_to - (lma + size))
1804 max_gap = pad_to - (lma + size);
1810 /* Symbol filtering must happen after the output sections
1811 have been created, but before their contents are set. */
1812 dhandle = NULL;
1813 if (convert_debugging)
1814 dhandle = read_debugging_info (ibfd, isympp, symcount, FALSE);
1816 if (strip_symbols == STRIP_DEBUG
1817 || strip_symbols == STRIP_ALL
1818 || strip_symbols == STRIP_UNNEEDED
1819 || strip_symbols == STRIP_NONDEBUG
1820 || discard_locals != LOCALS_UNDEF
1821 || localize_hidden
1822 || htab_elements (strip_specific_htab) != 0
1823 || htab_elements (keep_specific_htab) != 0
1824 || htab_elements (localize_specific_htab) != 0
1825 || htab_elements (globalize_specific_htab) != 0
1826 || htab_elements (keepglobal_specific_htab) != 0
1827 || htab_elements (weaken_specific_htab) != 0
1828 || prefix_symbols_string
1829 || sections_removed
1830 || sections_copied
1831 || convert_debugging
1832 || change_leading_char
1833 || remove_leading_char
1834 || redefine_sym_list
1835 || weaken)
1837 /* Mark symbols used in output relocations so that they
1838 are kept, even if they are local labels or static symbols.
1840 Note we iterate over the input sections examining their
1841 relocations since the relocations for the output sections
1842 haven't been set yet. mark_symbols_used_in_relocations will
1843 ignore input sections which have no corresponding output
1844 section. */
1845 if (strip_symbols != STRIP_ALL)
1846 bfd_map_over_sections (ibfd,
1847 mark_symbols_used_in_relocations,
1848 isympp);
1849 osympp = (asymbol **) xmalloc ((symcount + 1) * sizeof (asymbol *));
1850 symcount = filter_symbols (ibfd, obfd, osympp, isympp, symcount);
1853 if (convert_debugging && dhandle != NULL)
1855 if (! write_debugging_info (obfd, dhandle, &symcount, &osympp))
1857 status = 1;
1858 return FALSE;
1862 bfd_set_symtab (obfd, osympp, symcount);
1864 /* This has to happen after the symbol table has been set. */
1865 bfd_map_over_sections (ibfd, copy_section, obfd);
1867 if (add_sections != NULL)
1869 struct section_add *padd;
1871 for (padd = add_sections; padd != NULL; padd = padd->next)
1873 if (! bfd_set_section_contents (obfd, padd->section, padd->contents,
1874 0, padd->size))
1876 bfd_nonfatal_message (NULL, obfd, padd->section, NULL);
1877 return FALSE;
1882 if (gnu_debuglink_filename != NULL)
1884 if (! bfd_fill_in_gnu_debuglink_section
1885 (obfd, gnu_debuglink_section, gnu_debuglink_filename))
1887 bfd_nonfatal_message (NULL, obfd, NULL,
1888 _("cannot fill debug link section `%s'"),
1889 gnu_debuglink_filename);
1890 return FALSE;
1894 if (gap_fill_set || pad_to_set)
1896 bfd_byte *buf;
1897 int c, i;
1899 /* Fill in the gaps. */
1900 if (max_gap > 8192)
1901 max_gap = 8192;
1902 buf = (bfd_byte *) xmalloc (max_gap);
1903 memset (buf, gap_fill, max_gap);
1905 c = bfd_count_sections (obfd);
1906 for (i = 0; i < c; i++)
1908 if (gaps[i] != 0)
1910 bfd_size_type left;
1911 file_ptr off;
1913 left = gaps[i];
1914 off = bfd_section_size (obfd, osections[i]) - left;
1916 while (left > 0)
1918 bfd_size_type now;
1920 if (left > 8192)
1921 now = 8192;
1922 else
1923 now = left;
1925 if (! bfd_set_section_contents (obfd, osections[i], buf,
1926 off, now))
1928 bfd_nonfatal_message (NULL, obfd, osections[i], NULL);
1929 return FALSE;
1932 left -= now;
1933 off += now;
1939 /* Do not copy backend data if --extract-symbol is passed; anything
1940 that needs to look at the section contents will fail. */
1941 if (extract_symbol)
1942 return TRUE;
1944 /* Allow the BFD backend to copy any private data it understands
1945 from the input BFD to the output BFD. This is done last to
1946 permit the routine to look at the filtered symbol table, which is
1947 important for the ECOFF code at least. */
1948 if (! bfd_copy_private_bfd_data (ibfd, obfd))
1950 bfd_nonfatal_message (NULL, obfd, NULL,
1951 _("error copying private BFD data"));
1952 return FALSE;
1955 /* Switch to the alternate machine code. We have to do this at the
1956 very end, because we only initialize the header when we create
1957 the first section. */
1958 if (use_alt_mach_code != 0)
1960 if (! bfd_alt_mach_code (obfd, use_alt_mach_code))
1962 non_fatal (_("this target does not support %lu alternative machine codes"),
1963 use_alt_mach_code);
1964 if (bfd_get_flavour (obfd) == bfd_target_elf_flavour)
1966 non_fatal (_("treating that number as an absolute e_machine value instead"));
1967 elf_elfheader (obfd)->e_machine = use_alt_mach_code;
1969 else
1970 non_fatal (_("ignoring the alternative value"));
1974 return TRUE;
1977 /* Read each archive element in turn from IBFD, copy the
1978 contents to temp file, and keep the temp file handle.
1979 If 'force_output_target' is TRUE then make sure that
1980 all elements in the new archive are of the type
1981 'output_target'. */
1983 static void
1984 copy_archive (bfd *ibfd, bfd *obfd, const char *output_target,
1985 bfd_boolean force_output_target,
1986 const bfd_arch_info_type *input_arch)
1988 struct name_list
1990 struct name_list *next;
1991 const char *name;
1992 bfd *obfd;
1993 } *list, *l;
1994 bfd **ptr = &obfd->archive_head;
1995 bfd *this_element;
1996 char *dir;
1997 const char *filename;
1999 /* Make a temp directory to hold the contents. */
2000 dir = make_tempdir (bfd_get_filename (obfd));
2001 if (dir == NULL)
2002 fatal (_("cannot create tempdir for archive copying (error: %s)"),
2003 strerror (errno));
2005 obfd->has_armap = ibfd->has_armap;
2006 obfd->is_thin_archive = ibfd->is_thin_archive;
2008 list = NULL;
2010 this_element = bfd_openr_next_archived_file (ibfd, NULL);
2012 if (!bfd_set_format (obfd, bfd_get_format (ibfd)))
2014 status = 1;
2015 bfd_nonfatal_message (NULL, obfd, NULL, NULL);
2016 return;
2019 while (!status && this_element != NULL)
2021 char *output_name;
2022 bfd *output_bfd;
2023 bfd *last_element;
2024 struct stat buf;
2025 int stat_status = 0;
2026 bfd_boolean del = TRUE;
2027 bfd_boolean ok_object;
2029 /* Create an output file for this member. */
2030 output_name = concat (dir, "/",
2031 bfd_get_filename (this_element), (char *) 0);
2033 /* If the file already exists, make another temp dir. */
2034 if (stat (output_name, &buf) >= 0)
2036 output_name = make_tempdir (output_name);
2037 if (output_name == NULL)
2038 fatal (_("cannot create tempdir for archive copying (error: %s)"),
2039 strerror (errno));
2041 l = (struct name_list *) xmalloc (sizeof (struct name_list));
2042 l->name = output_name;
2043 l->next = list;
2044 l->obfd = NULL;
2045 list = l;
2046 output_name = concat (output_name, "/",
2047 bfd_get_filename (this_element), (char *) 0);
2050 if (preserve_dates)
2052 stat_status = bfd_stat_arch_elt (this_element, &buf);
2054 if (stat_status != 0)
2055 non_fatal (_("internal stat error on %s"),
2056 bfd_get_filename (this_element));
2059 l = (struct name_list *) xmalloc (sizeof (struct name_list));
2060 l->name = output_name;
2061 l->next = list;
2062 l->obfd = NULL;
2063 list = l;
2065 ok_object = bfd_check_format (this_element, bfd_object);
2066 if (!ok_object)
2067 bfd_nonfatal_message (NULL, this_element, NULL,
2068 _("Unable to recognise the format of file"));
2070 /* PR binutils/3110: Cope with archives
2071 containing multiple target types. */
2072 if (force_output_target || !ok_object)
2073 output_bfd = bfd_openw (output_name, output_target);
2074 else
2075 output_bfd = bfd_openw (output_name, bfd_get_target (this_element));
2077 if (output_bfd == NULL)
2079 bfd_nonfatal_message (output_name, NULL, NULL, NULL);
2080 status = 1;
2081 return;
2084 if (ok_object)
2086 del = !copy_object (this_element, output_bfd, input_arch);
2088 if (del && bfd_get_arch (this_element) == bfd_arch_unknown)
2089 /* Try again as an unknown object file. */
2090 ok_object = FALSE;
2091 else if (!bfd_close (output_bfd))
2093 bfd_nonfatal_message (output_name, NULL, NULL, NULL);
2094 /* Error in new object file. Don't change archive. */
2095 status = 1;
2099 if (!ok_object)
2101 del = !copy_unknown_object (this_element, output_bfd);
2102 if (!bfd_close_all_done (output_bfd))
2104 bfd_nonfatal_message (output_name, NULL, NULL, NULL);
2105 /* Error in new object file. Don't change archive. */
2106 status = 1;
2110 if (del)
2112 unlink (output_name);
2113 status = 1;
2115 else
2117 if (preserve_dates && stat_status == 0)
2118 set_times (output_name, &buf);
2120 /* Open the newly output file and attach to our list. */
2121 output_bfd = bfd_openr (output_name, output_target);
2123 l->obfd = output_bfd;
2125 *ptr = output_bfd;
2126 ptr = &output_bfd->archive_next;
2128 last_element = this_element;
2130 this_element = bfd_openr_next_archived_file (ibfd, last_element);
2132 bfd_close (last_element);
2135 *ptr = NULL;
2137 filename = bfd_get_filename (obfd);
2138 if (!bfd_close (obfd))
2140 status = 1;
2141 bfd_nonfatal_message (filename, NULL, NULL, NULL);
2142 return;
2145 filename = bfd_get_filename (ibfd);
2146 if (!bfd_close (ibfd))
2148 status = 1;
2149 bfd_nonfatal_message (filename, NULL, NULL, NULL);
2150 return;
2153 /* Delete all the files that we opened. */
2154 for (l = list; l != NULL; l = l->next)
2156 if (l->obfd == NULL)
2157 rmdir (l->name);
2158 else
2160 bfd_close (l->obfd);
2161 unlink (l->name);
2164 rmdir (dir);
2167 static void
2168 set_long_section_mode (bfd *output_bfd, bfd *input_bfd, enum long_section_name_handling style)
2170 /* This is only relevant to Coff targets. */
2171 if (bfd_get_flavour (output_bfd) == bfd_target_coff_flavour)
2173 if (style == KEEP
2174 && bfd_get_flavour (input_bfd) == bfd_target_coff_flavour)
2175 style = bfd_coff_long_section_names (input_bfd) ? ENABLE : DISABLE;
2176 bfd_coff_set_long_section_names (output_bfd, style != DISABLE);
2180 /* The top-level control. */
2182 static void
2183 copy_file (const char *input_filename, const char *output_filename,
2184 const char *input_target, const char *output_target,
2185 const bfd_arch_info_type *input_arch)
2187 bfd *ibfd;
2188 char **obj_matching;
2189 char **core_matching;
2190 off_t size = get_file_size (input_filename);
2192 if (size < 1)
2194 if (size == 0)
2195 non_fatal (_("error: the input file '%s' is empty"),
2196 input_filename);
2197 status = 1;
2198 return;
2201 /* To allow us to do "strip *" without dying on the first
2202 non-object file, failures are nonfatal. */
2203 ibfd = bfd_openr (input_filename, input_target);
2204 if (ibfd == NULL)
2206 bfd_nonfatal_message (input_filename, NULL, NULL, NULL);
2207 status = 1;
2208 return;
2211 switch (do_debug_sections)
2213 case compress:
2214 ibfd->flags |= BFD_COMPRESS;
2215 break;
2216 case decompress:
2217 ibfd->flags |= BFD_DECOMPRESS;
2218 break;
2219 default:
2220 break;
2223 if (bfd_check_format (ibfd, bfd_archive))
2225 bfd_boolean force_output_target;
2226 bfd *obfd;
2228 /* bfd_get_target does not return the correct value until
2229 bfd_check_format succeeds. */
2230 if (output_target == NULL)
2232 output_target = bfd_get_target (ibfd);
2233 force_output_target = FALSE;
2235 else
2236 force_output_target = TRUE;
2238 obfd = bfd_openw (output_filename, output_target);
2239 if (obfd == NULL)
2241 bfd_nonfatal_message (output_filename, NULL, NULL, NULL);
2242 status = 1;
2243 return;
2245 /* This is a no-op on non-Coff targets. */
2246 set_long_section_mode (obfd, ibfd, long_section_names);
2248 copy_archive (ibfd, obfd, output_target, force_output_target, input_arch);
2250 else if (bfd_check_format_matches (ibfd, bfd_object, &obj_matching))
2252 bfd *obfd;
2253 do_copy:
2255 /* bfd_get_target does not return the correct value until
2256 bfd_check_format succeeds. */
2257 if (output_target == NULL)
2258 output_target = bfd_get_target (ibfd);
2260 obfd = bfd_openw (output_filename, output_target);
2261 if (obfd == NULL)
2263 bfd_nonfatal_message (output_filename, NULL, NULL, NULL);
2264 status = 1;
2265 return;
2267 /* This is a no-op on non-Coff targets. */
2268 set_long_section_mode (obfd, ibfd, long_section_names);
2270 if (! copy_object (ibfd, obfd, input_arch))
2271 status = 1;
2273 if (!bfd_close (obfd))
2275 status = 1;
2276 bfd_nonfatal_message (output_filename, NULL, NULL, NULL);
2277 return;
2280 if (!bfd_close (ibfd))
2282 status = 1;
2283 bfd_nonfatal_message (input_filename, NULL, NULL, NULL);
2284 return;
2287 else
2289 bfd_error_type obj_error = bfd_get_error ();
2290 bfd_error_type core_error;
2292 if (bfd_check_format_matches (ibfd, bfd_core, &core_matching))
2294 /* This probably can't happen.. */
2295 if (obj_error == bfd_error_file_ambiguously_recognized)
2296 free (obj_matching);
2297 goto do_copy;
2300 core_error = bfd_get_error ();
2301 /* Report the object error in preference to the core error. */
2302 if (obj_error != core_error)
2303 bfd_set_error (obj_error);
2305 bfd_nonfatal_message (input_filename, NULL, NULL, NULL);
2307 if (obj_error == bfd_error_file_ambiguously_recognized)
2309 list_matching_formats (obj_matching);
2310 free (obj_matching);
2312 if (core_error == bfd_error_file_ambiguously_recognized)
2314 list_matching_formats (core_matching);
2315 free (core_matching);
2318 status = 1;
2322 /* Add a name to the section renaming list. */
2324 static void
2325 add_section_rename (const char * old_name, const char * new_name,
2326 flagword flags)
2328 section_rename * srename;
2330 /* Check for conflicts first. */
2331 for (srename = section_rename_list; srename != NULL; srename = srename->next)
2332 if (strcmp (srename->old_name, old_name) == 0)
2334 /* Silently ignore duplicate definitions. */
2335 if (strcmp (srename->new_name, new_name) == 0
2336 && srename->flags == flags)
2337 return;
2339 fatal (_("Multiple renames of section %s"), old_name);
2342 srename = (section_rename *) xmalloc (sizeof (* srename));
2344 srename->old_name = old_name;
2345 srename->new_name = new_name;
2346 srename->flags = flags;
2347 srename->next = section_rename_list;
2349 section_rename_list = srename;
2352 /* Check the section rename list for a new name of the input section
2353 ISECTION. Return the new name if one is found.
2354 Also set RETURNED_FLAGS to the flags to be used for this section. */
2356 static const char *
2357 find_section_rename (bfd * ibfd ATTRIBUTE_UNUSED, sec_ptr isection,
2358 flagword * returned_flags)
2360 const char * old_name = bfd_section_name (ibfd, isection);
2361 section_rename * srename;
2363 /* Default to using the flags of the input section. */
2364 * returned_flags = bfd_get_section_flags (ibfd, isection);
2366 for (srename = section_rename_list; srename != NULL; srename = srename->next)
2367 if (strcmp (srename->old_name, old_name) == 0)
2369 if (srename->flags != (flagword) -1)
2370 * returned_flags = srename->flags;
2372 return srename->new_name;
2375 return old_name;
2378 /* Once each of the sections is copied, we may still need to do some
2379 finalization work for private section headers. Do that here. */
2381 static void
2382 setup_bfd_headers (bfd *ibfd, bfd *obfd)
2384 /* Allow the BFD backend to copy any private data it understands
2385 from the input section to the output section. */
2386 if (! bfd_copy_private_header_data (ibfd, obfd))
2388 status = 1;
2389 bfd_nonfatal_message (NULL, ibfd, NULL,
2390 _("error in private header data"));
2391 return;
2394 /* All went well. */
2395 return;
2398 /* Create a section in OBFD with the same
2399 name and attributes as ISECTION in IBFD. */
2401 static void
2402 setup_section (bfd *ibfd, sec_ptr isection, void *obfdarg)
2404 bfd *obfd = (bfd *) obfdarg;
2405 struct section_list *p;
2406 sec_ptr osection;
2407 bfd_size_type size;
2408 bfd_vma vma;
2409 bfd_vma lma;
2410 flagword flags;
2411 const char *err;
2412 const char * name;
2413 char *prefix = NULL;
2414 bfd_boolean make_nobits;
2416 if (is_strip_section (ibfd, isection))
2417 return;
2419 p = find_section_list (bfd_section_name (ibfd, isection), FALSE);
2420 if (p != NULL)
2421 p->used = TRUE;
2423 /* Get the, possibly new, name of the output section. */
2424 name = find_section_rename (ibfd, isection, & flags);
2426 /* Prefix sections. */
2427 if ((prefix_alloc_sections_string)
2428 && (bfd_get_section_flags (ibfd, isection) & SEC_ALLOC))
2429 prefix = prefix_alloc_sections_string;
2430 else if (prefix_sections_string)
2431 prefix = prefix_sections_string;
2433 if (prefix)
2435 char *n;
2437 n = (char *) xmalloc (strlen (prefix) + strlen (name) + 1);
2438 strcpy (n, prefix);
2439 strcat (n, name);
2440 name = n;
2443 make_nobits = FALSE;
2444 if (p != NULL && p->set_flags)
2445 flags = p->flags | (flags & (SEC_HAS_CONTENTS | SEC_RELOC));
2446 else if (strip_symbols == STRIP_NONDEBUG
2447 && (flags & (SEC_ALLOC | SEC_GROUP)) != 0
2448 && !(ibfd->xvec->flavour == bfd_target_elf_flavour
2449 && elf_section_type (isection) == SHT_NOTE))
2451 flags &= ~(SEC_HAS_CONTENTS | SEC_LOAD | SEC_GROUP);
2452 if (obfd->xvec->flavour == bfd_target_elf_flavour)
2454 make_nobits = TRUE;
2456 /* Twiddle the input section flags so that it seems to
2457 elf.c:copy_private_bfd_data that section flags have not
2458 changed between input and output sections. This hack
2459 prevents wholesale rewriting of the program headers. */
2460 isection->flags &= ~(SEC_HAS_CONTENTS | SEC_LOAD | SEC_GROUP);
2464 osection = bfd_make_section_anyway_with_flags (obfd, name, flags);
2466 if (osection == NULL)
2468 err = _("failed to create output section");
2469 goto loser;
2472 if (make_nobits)
2473 elf_section_type (osection) = SHT_NOBITS;
2475 size = bfd_section_size (ibfd, isection);
2476 if (copy_byte >= 0)
2477 size = (size + interleave - 1) / interleave * copy_width;
2478 else if (extract_symbol)
2479 size = 0;
2480 if (! bfd_set_section_size (obfd, osection, size))
2482 err = _("failed to set size");
2483 goto loser;
2486 vma = bfd_section_vma (ibfd, isection);
2487 if (p != NULL && p->change_vma == CHANGE_MODIFY)
2488 vma += p->vma_val;
2489 else if (p != NULL && p->change_vma == CHANGE_SET)
2490 vma = p->vma_val;
2491 else
2492 vma += change_section_address;
2494 if (! bfd_set_section_vma (obfd, osection, vma))
2496 err = _("failed to set vma");
2497 goto loser;
2500 lma = isection->lma;
2501 if ((p != NULL) && p->change_lma != CHANGE_IGNORE)
2503 if (p->change_lma == CHANGE_MODIFY)
2504 lma += p->lma_val;
2505 else if (p->change_lma == CHANGE_SET)
2506 lma = p->lma_val;
2507 else
2508 abort ();
2510 else
2511 lma += change_section_address;
2513 osection->lma = lma;
2515 /* FIXME: This is probably not enough. If we change the LMA we
2516 may have to recompute the header for the file as well. */
2517 if (!bfd_set_section_alignment (obfd,
2518 osection,
2519 bfd_section_alignment (ibfd, isection)))
2521 err = _("failed to set alignment");
2522 goto loser;
2525 /* Copy merge entity size. */
2526 osection->entsize = isection->entsize;
2528 /* This used to be mangle_section; we do here to avoid using
2529 bfd_get_section_by_name since some formats allow multiple
2530 sections with the same name. */
2531 isection->output_section = osection;
2532 isection->output_offset = 0;
2534 /* Do not copy backend data if --extract-symbol is passed; anything
2535 that needs to look at the section contents will fail. */
2536 if (extract_symbol)
2537 return;
2539 if ((isection->flags & SEC_GROUP) != 0)
2541 asymbol *gsym = group_signature (isection);
2543 if (gsym != NULL)
2545 gsym->flags |= BSF_KEEP;
2546 if (ibfd->xvec->flavour == bfd_target_elf_flavour)
2547 elf_group_id (isection) = gsym;
2551 /* Allow the BFD backend to copy any private data it understands
2552 from the input section to the output section. */
2553 if (!bfd_copy_private_section_data (ibfd, isection, obfd, osection))
2555 err = _("failed to copy private data");
2556 goto loser;
2559 /* All went well. */
2560 return;
2562 loser:
2563 status = 1;
2564 bfd_nonfatal_message (NULL, obfd, osection, err);
2567 /* Copy the data of input section ISECTION of IBFD
2568 to an output section with the same name in OBFD.
2569 If stripping then don't copy any relocation info. */
2571 static void
2572 copy_section (bfd *ibfd, sec_ptr isection, void *obfdarg)
2574 bfd *obfd = (bfd *) obfdarg;
2575 struct section_list *p;
2576 arelent **relpp;
2577 long relcount;
2578 sec_ptr osection;
2579 bfd_size_type size;
2580 long relsize;
2581 flagword flags;
2583 /* If we have already failed earlier on,
2584 do not keep on generating complaints now. */
2585 if (status != 0)
2586 return;
2588 if (is_strip_section (ibfd, isection))
2589 return;
2591 flags = bfd_get_section_flags (ibfd, isection);
2592 if ((flags & SEC_GROUP) != 0)
2593 return;
2595 osection = isection->output_section;
2596 size = bfd_get_section_size (isection);
2598 if (size == 0 || osection == 0)
2599 return;
2601 if (extract_symbol)
2602 return;
2604 p = find_section_list (bfd_get_section_name (ibfd, isection), FALSE);
2606 /* Core files do not need to be relocated. */
2607 if (bfd_get_format (obfd) == bfd_core)
2608 relsize = 0;
2609 else
2611 relsize = bfd_get_reloc_upper_bound (ibfd, isection);
2613 if (relsize < 0)
2615 /* Do not complain if the target does not support relocations. */
2616 if (relsize == -1 && bfd_get_error () == bfd_error_invalid_operation)
2617 relsize = 0;
2618 else
2620 status = 1;
2621 bfd_nonfatal_message (NULL, ibfd, isection, NULL);
2622 return;
2627 if (relsize == 0)
2628 bfd_set_reloc (obfd, osection, NULL, 0);
2629 else
2631 relpp = (arelent **) xmalloc (relsize);
2632 relcount = bfd_canonicalize_reloc (ibfd, isection, relpp, isympp);
2633 if (relcount < 0)
2635 status = 1;
2636 bfd_nonfatal_message (NULL, ibfd, isection,
2637 _("relocation count is negative"));
2638 return;
2641 if (strip_symbols == STRIP_ALL)
2643 /* Remove relocations which are not in
2644 keep_strip_specific_list. */
2645 arelent **temp_relpp;
2646 long temp_relcount = 0;
2647 long i;
2649 temp_relpp = (arelent **) xmalloc (relsize);
2650 for (i = 0; i < relcount; i++)
2651 if (is_specified_symbol (bfd_asymbol_name (*relpp[i]->sym_ptr_ptr),
2652 keep_specific_htab))
2653 temp_relpp [temp_relcount++] = relpp [i];
2654 relcount = temp_relcount;
2655 free (relpp);
2656 relpp = temp_relpp;
2659 bfd_set_reloc (obfd, osection, relcount == 0 ? NULL : relpp, relcount);
2660 if (relcount == 0)
2661 free (relpp);
2664 if (bfd_get_section_flags (ibfd, isection) & SEC_HAS_CONTENTS
2665 && bfd_get_section_flags (obfd, osection) & SEC_HAS_CONTENTS)
2667 bfd_byte *memhunk = NULL;
2669 if (!bfd_get_full_section_contents (ibfd, isection, &memhunk))
2671 status = 1;
2672 bfd_nonfatal_message (NULL, ibfd, isection, NULL);
2673 return;
2676 if (reverse_bytes)
2678 /* We don't handle leftover bytes (too many possible behaviors,
2679 and we don't know what the user wants). The section length
2680 must be a multiple of the number of bytes to swap. */
2681 if ((size % reverse_bytes) == 0)
2683 unsigned long i, j;
2684 bfd_byte b;
2686 for (i = 0; i < size; i += reverse_bytes)
2687 for (j = 0; j < (unsigned long)(reverse_bytes / 2); j++)
2689 bfd_byte *m = (bfd_byte *) memhunk;
2691 b = m[i + j];
2692 m[i + j] = m[(i + reverse_bytes) - (j + 1)];
2693 m[(i + reverse_bytes) - (j + 1)] = b;
2696 else
2697 /* User must pad the section up in order to do this. */
2698 fatal (_("cannot reverse bytes: length of section %s must be evenly divisible by %d"),
2699 bfd_section_name (ibfd, isection), reverse_bytes);
2702 if (copy_byte >= 0)
2704 /* Keep only every `copy_byte'th byte in MEMHUNK. */
2705 char *from = (char *) memhunk + copy_byte;
2706 char *to = (char *) memhunk;
2707 char *end = (char *) memhunk + size;
2708 int i;
2710 for (; from < end; from += interleave)
2711 for (i = 0; i < copy_width; i++)
2712 *to++ = from[i];
2714 size = (size + interleave - 1 - copy_byte) / interleave * copy_width;
2715 osection->lma /= interleave;
2718 if (!bfd_set_section_contents (obfd, osection, memhunk, 0, size))
2720 status = 1;
2721 bfd_nonfatal_message (NULL, obfd, osection, NULL);
2722 return;
2724 free (memhunk);
2726 else if (p != NULL && p->set_flags && (p->flags & SEC_HAS_CONTENTS) != 0)
2728 void *memhunk = xmalloc (size);
2730 /* We don't permit the user to turn off the SEC_HAS_CONTENTS
2731 flag--they can just remove the section entirely and add it
2732 back again. However, we do permit them to turn on the
2733 SEC_HAS_CONTENTS flag, and take it to mean that the section
2734 contents should be zeroed out. */
2736 memset (memhunk, 0, size);
2737 if (! bfd_set_section_contents (obfd, osection, memhunk, 0, size))
2739 status = 1;
2740 bfd_nonfatal_message (NULL, obfd, osection, NULL);
2741 return;
2743 free (memhunk);
2747 /* Get all the sections. This is used when --gap-fill or --pad-to is
2748 used. */
2750 static void
2751 get_sections (bfd *obfd ATTRIBUTE_UNUSED, asection *osection, void *secppparg)
2753 asection ***secppp = (asection ***) secppparg;
2755 **secppp = osection;
2756 ++(*secppp);
2759 /* Sort sections by VMA. This is called via qsort, and is used when
2760 --gap-fill or --pad-to is used. We force non loadable or empty
2761 sections to the front, where they are easier to ignore. */
2763 static int
2764 compare_section_lma (const void *arg1, const void *arg2)
2766 const asection *const *sec1 = (const asection * const *) arg1;
2767 const asection *const *sec2 = (const asection * const *) arg2;
2768 flagword flags1, flags2;
2770 /* Sort non loadable sections to the front. */
2771 flags1 = (*sec1)->flags;
2772 flags2 = (*sec2)->flags;
2773 if ((flags1 & SEC_HAS_CONTENTS) == 0
2774 || (flags1 & SEC_LOAD) == 0)
2776 if ((flags2 & SEC_HAS_CONTENTS) != 0
2777 && (flags2 & SEC_LOAD) != 0)
2778 return -1;
2780 else
2782 if ((flags2 & SEC_HAS_CONTENTS) == 0
2783 || (flags2 & SEC_LOAD) == 0)
2784 return 1;
2787 /* Sort sections by LMA. */
2788 if ((*sec1)->lma > (*sec2)->lma)
2789 return 1;
2790 else if ((*sec1)->lma < (*sec2)->lma)
2791 return -1;
2793 /* Sort sections with the same LMA by size. */
2794 if (bfd_get_section_size (*sec1) > bfd_get_section_size (*sec2))
2795 return 1;
2796 else if (bfd_get_section_size (*sec1) < bfd_get_section_size (*sec2))
2797 return -1;
2799 return 0;
2802 /* Mark all the symbols which will be used in output relocations with
2803 the BSF_KEEP flag so that those symbols will not be stripped.
2805 Ignore relocations which will not appear in the output file. */
2807 static void
2808 mark_symbols_used_in_relocations (bfd *ibfd, sec_ptr isection, void *symbolsarg)
2810 asymbol **symbols = (asymbol **) symbolsarg;
2811 long relsize;
2812 arelent **relpp;
2813 long relcount, i;
2815 /* Ignore an input section with no corresponding output section. */
2816 if (isection->output_section == NULL)
2817 return;
2819 relsize = bfd_get_reloc_upper_bound (ibfd, isection);
2820 if (relsize < 0)
2822 /* Do not complain if the target does not support relocations. */
2823 if (relsize == -1 && bfd_get_error () == bfd_error_invalid_operation)
2824 return;
2825 bfd_fatal (bfd_get_filename (ibfd));
2828 if (relsize == 0)
2829 return;
2831 relpp = (arelent **) xmalloc (relsize);
2832 relcount = bfd_canonicalize_reloc (ibfd, isection, relpp, symbols);
2833 if (relcount < 0)
2834 bfd_fatal (bfd_get_filename (ibfd));
2836 /* Examine each symbol used in a relocation. If it's not one of the
2837 special bfd section symbols, then mark it with BSF_KEEP. */
2838 for (i = 0; i < relcount; i++)
2840 if (*relpp[i]->sym_ptr_ptr != bfd_com_section_ptr->symbol
2841 && *relpp[i]->sym_ptr_ptr != bfd_abs_section_ptr->symbol
2842 && *relpp[i]->sym_ptr_ptr != bfd_und_section_ptr->symbol)
2843 (*relpp[i]->sym_ptr_ptr)->flags |= BSF_KEEP;
2846 if (relpp != NULL)
2847 free (relpp);
2850 /* Write out debugging information. */
2852 static bfd_boolean
2853 write_debugging_info (bfd *obfd, void *dhandle,
2854 long *symcountp ATTRIBUTE_UNUSED,
2855 asymbol ***symppp ATTRIBUTE_UNUSED)
2857 if (bfd_get_flavour (obfd) == bfd_target_ieee_flavour)
2858 return write_ieee_debugging_info (obfd, dhandle);
2860 if (bfd_get_flavour (obfd) == bfd_target_coff_flavour
2861 || bfd_get_flavour (obfd) == bfd_target_elf_flavour)
2863 bfd_byte *syms, *strings;
2864 bfd_size_type symsize, stringsize;
2865 asection *stabsec, *stabstrsec;
2866 flagword flags;
2868 if (! write_stabs_in_sections_debugging_info (obfd, dhandle, &syms,
2869 &symsize, &strings,
2870 &stringsize))
2871 return FALSE;
2873 flags = SEC_HAS_CONTENTS | SEC_READONLY | SEC_DEBUGGING;
2874 stabsec = bfd_make_section_with_flags (obfd, ".stab", flags);
2875 stabstrsec = bfd_make_section_with_flags (obfd, ".stabstr", flags);
2876 if (stabsec == NULL
2877 || stabstrsec == NULL
2878 || ! bfd_set_section_size (obfd, stabsec, symsize)
2879 || ! bfd_set_section_size (obfd, stabstrsec, stringsize)
2880 || ! bfd_set_section_alignment (obfd, stabsec, 2)
2881 || ! bfd_set_section_alignment (obfd, stabstrsec, 0))
2883 bfd_nonfatal_message (NULL, obfd, NULL,
2884 _("can't create debugging section"));
2885 return FALSE;
2888 /* We can get away with setting the section contents now because
2889 the next thing the caller is going to do is copy over the
2890 real sections. We may someday have to split the contents
2891 setting out of this function. */
2892 if (! bfd_set_section_contents (obfd, stabsec, syms, 0, symsize)
2893 || ! bfd_set_section_contents (obfd, stabstrsec, strings, 0,
2894 stringsize))
2896 bfd_nonfatal_message (NULL, obfd, NULL,
2897 _("can't set debugging section contents"));
2898 return FALSE;
2901 return TRUE;
2904 bfd_nonfatal_message (NULL, obfd, NULL,
2905 _("don't know how to write debugging information for %s"),
2906 bfd_get_target (obfd));
2907 return FALSE;
2910 static int
2911 strip_main (int argc, char *argv[])
2913 char *input_target = NULL;
2914 char *output_target = NULL;
2915 bfd_boolean show_version = FALSE;
2916 bfd_boolean formats_info = FALSE;
2917 int c;
2918 int i;
2919 struct section_list *p;
2920 char *output_file = NULL;
2922 while ((c = getopt_long (argc, argv, "I:O:F:K:N:R:o:sSpdgxXHhVvw",
2923 strip_options, (int *) 0)) != EOF)
2925 switch (c)
2927 case 'I':
2928 input_target = optarg;
2929 break;
2930 case 'O':
2931 output_target = optarg;
2932 break;
2933 case 'F':
2934 input_target = output_target = optarg;
2935 break;
2936 case 'R':
2937 p = find_section_list (optarg, TRUE);
2938 p->remove = TRUE;
2939 sections_removed = TRUE;
2940 break;
2941 case 's':
2942 strip_symbols = STRIP_ALL;
2943 break;
2944 case 'S':
2945 case 'g':
2946 case 'd': /* Historic BSD alias for -g. Used by early NetBSD. */
2947 strip_symbols = STRIP_DEBUG;
2948 break;
2949 case OPTION_STRIP_UNNEEDED:
2950 strip_symbols = STRIP_UNNEEDED;
2951 break;
2952 case 'K':
2953 add_specific_symbol (optarg, keep_specific_htab);
2954 break;
2955 case 'N':
2956 add_specific_symbol (optarg, strip_specific_htab);
2957 break;
2958 case 'o':
2959 output_file = optarg;
2960 break;
2961 case 'p':
2962 preserve_dates = TRUE;
2963 break;
2964 case 'x':
2965 discard_locals = LOCALS_ALL;
2966 break;
2967 case 'X':
2968 discard_locals = LOCALS_START_L;
2969 break;
2970 case 'v':
2971 verbose = TRUE;
2972 break;
2973 case 'V':
2974 show_version = TRUE;
2975 break;
2976 case OPTION_FORMATS_INFO:
2977 formats_info = TRUE;
2978 break;
2979 case OPTION_ONLY_KEEP_DEBUG:
2980 strip_symbols = STRIP_NONDEBUG;
2981 break;
2982 case OPTION_KEEP_FILE_SYMBOLS:
2983 keep_file_symbols = 1;
2984 break;
2985 case 0:
2986 /* We've been given a long option. */
2987 break;
2988 case 'w':
2989 wildcard = TRUE;
2990 break;
2991 case 'H':
2992 case 'h':
2993 strip_usage (stdout, 0);
2994 default:
2995 strip_usage (stderr, 1);
2999 if (formats_info)
3001 display_info ();
3002 return 0;
3005 if (show_version)
3006 print_version ("strip");
3008 /* Default is to strip all symbols. */
3009 if (strip_symbols == STRIP_UNDEF
3010 && discard_locals == LOCALS_UNDEF
3011 && htab_elements (strip_specific_htab) == 0)
3012 strip_symbols = STRIP_ALL;
3014 if (output_target == NULL)
3015 output_target = input_target;
3017 i = optind;
3018 if (i == argc
3019 || (output_file != NULL && (i + 1) < argc))
3020 strip_usage (stderr, 1);
3022 for (; i < argc; i++)
3024 int hold_status = status;
3025 struct stat statbuf;
3026 char *tmpname;
3028 if (get_file_size (argv[i]) < 1)
3030 status = 1;
3031 continue;
3034 if (preserve_dates)
3035 /* No need to check the return value of stat().
3036 It has already been checked in get_file_size(). */
3037 stat (argv[i], &statbuf);
3039 if (output_file == NULL
3040 || filename_cmp (argv[i], output_file) == 0)
3041 tmpname = make_tempname (argv[i]);
3042 else
3043 tmpname = output_file;
3045 if (tmpname == NULL)
3047 bfd_nonfatal_message (argv[i], NULL, NULL,
3048 _("could not create temporary file to hold stripped copy"));
3049 status = 1;
3050 continue;
3053 status = 0;
3054 copy_file (argv[i], tmpname, input_target, output_target, NULL);
3055 if (status == 0)
3057 if (preserve_dates)
3058 set_times (tmpname, &statbuf);
3059 if (output_file != tmpname)
3060 status = (smart_rename (tmpname,
3061 output_file ? output_file : argv[i],
3062 preserve_dates) != 0);
3063 if (status == 0)
3064 status = hold_status;
3066 else
3067 unlink_if_ordinary (tmpname);
3068 if (output_file != tmpname)
3069 free (tmpname);
3072 return status;
3075 /* Set up PE subsystem. */
3077 static void
3078 set_pe_subsystem (const char *s)
3080 const char *version, *subsystem;
3081 size_t i;
3082 static const struct
3084 const char *name;
3085 const char set_def;
3086 const short value;
3088 v[] =
3090 { "native", 0, IMAGE_SUBSYSTEM_NATIVE },
3091 { "windows", 0, IMAGE_SUBSYSTEM_WINDOWS_GUI },
3092 { "console", 0, IMAGE_SUBSYSTEM_WINDOWS_CUI },
3093 { "posix", 0, IMAGE_SUBSYSTEM_POSIX_CUI },
3094 { "wince", 0, IMAGE_SUBSYSTEM_WINDOWS_CE_GUI },
3095 { "efi-app", 1, IMAGE_SUBSYSTEM_EFI_APPLICATION },
3096 { "efi-bsd", 1, IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER },
3097 { "efi-rtd", 1, IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER },
3098 { "sal-rtd", 1, IMAGE_SUBSYSTEM_SAL_RUNTIME_DRIVER },
3099 { "xbox", 0, IMAGE_SUBSYSTEM_XBOX }
3101 short value;
3102 char *copy;
3103 int set_def = -1;
3105 /* Check for the presence of a version number. */
3106 version = strchr (s, ':');
3107 if (version == NULL)
3108 subsystem = s;
3109 else
3111 int len = version - s;
3112 copy = xstrdup (s);
3113 subsystem = copy;
3114 copy[len] = '\0';
3115 version = copy + 1 + len;
3116 pe_major_subsystem_version = strtoul (version, &copy, 0);
3117 if (*copy == '.')
3118 pe_minor_subsystem_version = strtoul (copy + 1, &copy, 0);
3119 if (*copy != '\0')
3120 non_fatal (_("%s: bad version in PE subsystem"), s);
3123 /* Check for numeric subsystem. */
3124 value = (short) strtol (subsystem, &copy, 0);
3125 if (*copy == '\0')
3127 for (i = 0; i < ARRAY_SIZE (v); i++)
3128 if (v[i].value == value)
3130 pe_subsystem = value;
3131 set_def = v[i].set_def;
3132 break;
3135 else
3137 /* Search for subsystem by name. */
3138 for (i = 0; i < ARRAY_SIZE (v); i++)
3139 if (strcmp (subsystem, v[i].name) == 0)
3141 pe_subsystem = v[i].value;
3142 set_def = v[i].set_def;
3143 break;
3147 switch (set_def)
3149 case -1:
3150 fatal (_("unknown PE subsystem: %s"), s);
3151 break;
3152 case 0:
3153 break;
3154 default:
3155 if (pe_file_alignment == (bfd_vma) -1)
3156 pe_file_alignment = PE_DEF_FILE_ALIGNMENT;
3157 if (pe_section_alignment == (bfd_vma) -1)
3158 pe_section_alignment = PE_DEF_SECTION_ALIGNMENT;
3159 break;
3161 if (s != subsystem)
3162 free ((char *) subsystem);
3165 /* Convert EFI target to PEI target. */
3167 static void
3168 convert_efi_target (char *efi)
3170 efi[0] = 'p';
3171 efi[1] = 'e';
3172 efi[2] = 'i';
3174 if (strcmp (efi + 4, "ia32") == 0)
3176 /* Change ia32 to i386. */
3177 efi[5]= '3';
3178 efi[6]= '8';
3179 efi[7]= '6';
3181 else if (strcmp (efi + 4, "x86_64") == 0)
3183 /* Change x86_64 to x86-64. */
3184 efi[7] = '-';
3188 static int
3189 copy_main (int argc, char *argv[])
3191 char *input_filename = NULL;
3192 char *output_filename = NULL;
3193 char *tmpname;
3194 char *input_target = NULL;
3195 char *output_target = NULL;
3196 bfd_boolean show_version = FALSE;
3197 bfd_boolean change_warn = TRUE;
3198 bfd_boolean formats_info = FALSE;
3199 int c;
3200 struct section_list *p;
3201 struct stat statbuf;
3202 const bfd_arch_info_type *input_arch = NULL;
3204 while ((c = getopt_long (argc, argv, "b:B:i:I:j:K:N:s:O:d:F:L:G:R:SpgxXHhVvW:w",
3205 copy_options, (int *) 0)) != EOF)
3207 switch (c)
3209 case 'b':
3210 copy_byte = atoi (optarg);
3211 if (copy_byte < 0)
3212 fatal (_("byte number must be non-negative"));
3213 break;
3215 case 'B':
3216 input_arch = bfd_scan_arch (optarg);
3217 if (input_arch == NULL)
3218 fatal (_("architecture %s unknown"), optarg);
3219 break;
3221 case 'i':
3222 if (optarg)
3224 interleave = atoi (optarg);
3225 if (interleave < 1)
3226 fatal (_("interleave must be positive"));
3228 else
3229 interleave = 4;
3230 break;
3232 case OPTION_INTERLEAVE_WIDTH:
3233 copy_width = atoi (optarg);
3234 if (copy_width < 1)
3235 fatal(_("interleave width must be positive"));
3236 break;
3238 case 'I':
3239 case 's': /* "source" - 'I' is preferred */
3240 input_target = optarg;
3241 break;
3243 case 'O':
3244 case 'd': /* "destination" - 'O' is preferred */
3245 output_target = optarg;
3246 break;
3248 case 'F':
3249 input_target = output_target = optarg;
3250 break;
3252 case 'j':
3253 p = find_section_list (optarg, TRUE);
3254 if (p->remove)
3255 fatal (_("%s both copied and removed"), optarg);
3256 p->copy = TRUE;
3257 sections_copied = TRUE;
3258 break;
3260 case 'R':
3261 p = find_section_list (optarg, TRUE);
3262 if (p->copy)
3263 fatal (_("%s both copied and removed"), optarg);
3264 p->remove = TRUE;
3265 sections_removed = TRUE;
3266 break;
3268 case 'S':
3269 strip_symbols = STRIP_ALL;
3270 break;
3272 case 'g':
3273 strip_symbols = STRIP_DEBUG;
3274 break;
3276 case OPTION_STRIP_UNNEEDED:
3277 strip_symbols = STRIP_UNNEEDED;
3278 break;
3280 case OPTION_ONLY_KEEP_DEBUG:
3281 strip_symbols = STRIP_NONDEBUG;
3282 break;
3284 case OPTION_KEEP_FILE_SYMBOLS:
3285 keep_file_symbols = 1;
3286 break;
3288 case OPTION_ADD_GNU_DEBUGLINK:
3289 gnu_debuglink_filename = optarg;
3290 break;
3292 case 'K':
3293 add_specific_symbol (optarg, keep_specific_htab);
3294 break;
3296 case 'N':
3297 add_specific_symbol (optarg, strip_specific_htab);
3298 break;
3300 case OPTION_STRIP_UNNEEDED_SYMBOL:
3301 add_specific_symbol (optarg, strip_unneeded_htab);
3302 break;
3304 case 'L':
3305 add_specific_symbol (optarg, localize_specific_htab);
3306 break;
3308 case OPTION_GLOBALIZE_SYMBOL:
3309 add_specific_symbol (optarg, globalize_specific_htab);
3310 break;
3312 case 'G':
3313 add_specific_symbol (optarg, keepglobal_specific_htab);
3314 break;
3316 case 'W':
3317 add_specific_symbol (optarg, weaken_specific_htab);
3318 break;
3320 case 'p':
3321 preserve_dates = TRUE;
3322 break;
3324 case 'w':
3325 wildcard = TRUE;
3326 break;
3328 case 'x':
3329 discard_locals = LOCALS_ALL;
3330 break;
3332 case 'X':
3333 discard_locals = LOCALS_START_L;
3334 break;
3336 case 'v':
3337 verbose = TRUE;
3338 break;
3340 case 'V':
3341 show_version = TRUE;
3342 break;
3344 case OPTION_FORMATS_INFO:
3345 formats_info = TRUE;
3346 break;
3348 case OPTION_WEAKEN:
3349 weaken = TRUE;
3350 break;
3352 case OPTION_ADD_SECTION:
3354 const char *s;
3355 size_t off, alloc;
3356 struct section_add *pa;
3357 FILE *f;
3359 s = strchr (optarg, '=');
3361 if (s == NULL)
3362 fatal (_("bad format for %s"), "--add-section");
3364 pa = (struct section_add *) xmalloc (sizeof (struct section_add));
3365 pa->name = xstrndup (optarg, s - optarg);
3366 pa->filename = s + 1;
3368 /* We don't use get_file_size so that we can do
3369 --add-section .note.GNU_stack=/dev/null
3370 get_file_size doesn't work on /dev/null. */
3372 f = fopen (pa->filename, FOPEN_RB);
3373 if (f == NULL)
3374 fatal (_("cannot open: %s: %s"),
3375 pa->filename, strerror (errno));
3377 off = 0;
3378 alloc = 4096;
3379 pa->contents = (bfd_byte *) xmalloc (alloc);
3380 while (!feof (f))
3382 off_t got;
3384 if (off == alloc)
3386 alloc <<= 1;
3387 pa->contents = (bfd_byte *) xrealloc (pa->contents, alloc);
3390 got = fread (pa->contents + off, 1, alloc - off, f);
3391 if (ferror (f))
3392 fatal (_("%s: fread failed"), pa->filename);
3394 off += got;
3397 pa->size = off;
3399 fclose (f);
3401 pa->next = add_sections;
3402 add_sections = pa;
3404 break;
3406 case OPTION_CHANGE_START:
3407 change_start = parse_vma (optarg, "--change-start");
3408 break;
3410 case OPTION_CHANGE_SECTION_ADDRESS:
3411 case OPTION_CHANGE_SECTION_LMA:
3412 case OPTION_CHANGE_SECTION_VMA:
3414 const char *s;
3415 int len;
3416 char *name;
3417 char *option = NULL;
3418 bfd_vma val;
3419 enum change_action what = CHANGE_IGNORE;
3421 switch (c)
3423 case OPTION_CHANGE_SECTION_ADDRESS:
3424 option = "--change-section-address";
3425 break;
3426 case OPTION_CHANGE_SECTION_LMA:
3427 option = "--change-section-lma";
3428 break;
3429 case OPTION_CHANGE_SECTION_VMA:
3430 option = "--change-section-vma";
3431 break;
3434 s = strchr (optarg, '=');
3435 if (s == NULL)
3437 s = strchr (optarg, '+');
3438 if (s == NULL)
3440 s = strchr (optarg, '-');
3441 if (s == NULL)
3442 fatal (_("bad format for %s"), option);
3446 len = s - optarg;
3447 name = (char *) xmalloc (len + 1);
3448 strncpy (name, optarg, len);
3449 name[len] = '\0';
3451 p = find_section_list (name, TRUE);
3453 val = parse_vma (s + 1, option);
3455 switch (*s)
3457 case '=': what = CHANGE_SET; break;
3458 case '-': val = - val; /* Drop through. */
3459 case '+': what = CHANGE_MODIFY; break;
3462 switch (c)
3464 case OPTION_CHANGE_SECTION_ADDRESS:
3465 p->change_vma = what;
3466 p->vma_val = val;
3467 /* Drop through. */
3469 case OPTION_CHANGE_SECTION_LMA:
3470 p->change_lma = what;
3471 p->lma_val = val;
3472 break;
3474 case OPTION_CHANGE_SECTION_VMA:
3475 p->change_vma = what;
3476 p->vma_val = val;
3477 break;
3480 break;
3482 case OPTION_CHANGE_ADDRESSES:
3483 change_section_address = parse_vma (optarg, "--change-addresses");
3484 change_start = change_section_address;
3485 break;
3487 case OPTION_CHANGE_WARNINGS:
3488 change_warn = TRUE;
3489 break;
3491 case OPTION_CHANGE_LEADING_CHAR:
3492 change_leading_char = TRUE;
3493 break;
3495 case OPTION_COMPRESS_DEBUG_SECTIONS:
3496 do_debug_sections = compress;
3497 break;
3499 case OPTION_DEBUGGING:
3500 convert_debugging = TRUE;
3501 break;
3503 case OPTION_DECOMPRESS_DEBUG_SECTIONS:
3504 do_debug_sections = decompress;
3505 break;
3507 case OPTION_GAP_FILL:
3509 bfd_vma gap_fill_vma;
3511 gap_fill_vma = parse_vma (optarg, "--gap-fill");
3512 gap_fill = (bfd_byte) gap_fill_vma;
3513 if ((bfd_vma) gap_fill != gap_fill_vma)
3515 char buff[20];
3517 sprintf_vma (buff, gap_fill_vma);
3519 non_fatal (_("Warning: truncating gap-fill from 0x%s to 0x%x"),
3520 buff, gap_fill);
3522 gap_fill_set = TRUE;
3524 break;
3526 case OPTION_NO_CHANGE_WARNINGS:
3527 change_warn = FALSE;
3528 break;
3530 case OPTION_PAD_TO:
3531 pad_to = parse_vma (optarg, "--pad-to");
3532 pad_to_set = TRUE;
3533 break;
3535 case OPTION_REMOVE_LEADING_CHAR:
3536 remove_leading_char = TRUE;
3537 break;
3539 case OPTION_REDEFINE_SYM:
3541 /* Push this redefinition onto redefine_symbol_list. */
3543 int len;
3544 const char *s;
3545 const char *nextarg;
3546 char *source, *target;
3548 s = strchr (optarg, '=');
3549 if (s == NULL)
3550 fatal (_("bad format for %s"), "--redefine-sym");
3552 len = s - optarg;
3553 source = (char *) xmalloc (len + 1);
3554 strncpy (source, optarg, len);
3555 source[len] = '\0';
3557 nextarg = s + 1;
3558 len = strlen (nextarg);
3559 target = (char *) xmalloc (len + 1);
3560 strcpy (target, nextarg);
3562 redefine_list_append ("--redefine-sym", source, target);
3564 free (source);
3565 free (target);
3567 break;
3569 case OPTION_REDEFINE_SYMS:
3570 add_redefine_syms_file (optarg);
3571 break;
3573 case OPTION_SET_SECTION_FLAGS:
3575 const char *s;
3576 int len;
3577 char *name;
3579 s = strchr (optarg, '=');
3580 if (s == NULL)
3581 fatal (_("bad format for %s"), "--set-section-flags");
3583 len = s - optarg;
3584 name = (char *) xmalloc (len + 1);
3585 strncpy (name, optarg, len);
3586 name[len] = '\0';
3588 p = find_section_list (name, TRUE);
3590 p->set_flags = TRUE;
3591 p->flags = parse_flags (s + 1);
3593 break;
3595 case OPTION_RENAME_SECTION:
3597 flagword flags;
3598 const char *eq, *fl;
3599 char *old_name;
3600 char *new_name;
3601 unsigned int len;
3603 eq = strchr (optarg, '=');
3604 if (eq == NULL)
3605 fatal (_("bad format for %s"), "--rename-section");
3607 len = eq - optarg;
3608 if (len == 0)
3609 fatal (_("bad format for %s"), "--rename-section");
3611 old_name = (char *) xmalloc (len + 1);
3612 strncpy (old_name, optarg, len);
3613 old_name[len] = 0;
3615 eq++;
3616 fl = strchr (eq, ',');
3617 if (fl)
3619 flags = parse_flags (fl + 1);
3620 len = fl - eq;
3622 else
3624 flags = -1;
3625 len = strlen (eq);
3628 if (len == 0)
3629 fatal (_("bad format for %s"), "--rename-section");
3631 new_name = (char *) xmalloc (len + 1);
3632 strncpy (new_name, eq, len);
3633 new_name[len] = 0;
3635 add_section_rename (old_name, new_name, flags);
3637 break;
3639 case OPTION_SET_START:
3640 set_start = parse_vma (optarg, "--set-start");
3641 set_start_set = TRUE;
3642 break;
3644 case OPTION_SREC_LEN:
3645 Chunk = parse_vma (optarg, "--srec-len");
3646 break;
3648 case OPTION_SREC_FORCES3:
3649 S3Forced = TRUE;
3650 break;
3652 case OPTION_STRIP_SYMBOLS:
3653 add_specific_symbols (optarg, strip_specific_htab);
3654 break;
3656 case OPTION_STRIP_UNNEEDED_SYMBOLS:
3657 add_specific_symbols (optarg, strip_unneeded_htab);
3658 break;
3660 case OPTION_KEEP_SYMBOLS:
3661 add_specific_symbols (optarg, keep_specific_htab);
3662 break;
3664 case OPTION_LOCALIZE_HIDDEN:
3665 localize_hidden = TRUE;
3666 break;
3668 case OPTION_LOCALIZE_SYMBOLS:
3669 add_specific_symbols (optarg, localize_specific_htab);
3670 break;
3672 case OPTION_LONG_SECTION_NAMES:
3673 if (!strcmp ("enable", optarg))
3674 long_section_names = ENABLE;
3675 else if (!strcmp ("disable", optarg))
3676 long_section_names = DISABLE;
3677 else if (!strcmp ("keep", optarg))
3678 long_section_names = KEEP;
3679 else
3680 fatal (_("unknown long section names option '%s'"), optarg);
3681 break;
3683 case OPTION_GLOBALIZE_SYMBOLS:
3684 add_specific_symbols (optarg, globalize_specific_htab);
3685 break;
3687 case OPTION_KEEPGLOBAL_SYMBOLS:
3688 add_specific_symbols (optarg, keepglobal_specific_htab);
3689 break;
3691 case OPTION_WEAKEN_SYMBOLS:
3692 add_specific_symbols (optarg, weaken_specific_htab);
3693 break;
3695 case OPTION_ALT_MACH_CODE:
3696 use_alt_mach_code = strtoul (optarg, NULL, 0);
3697 if (use_alt_mach_code == 0)
3698 fatal (_("unable to parse alternative machine code"));
3699 break;
3701 case OPTION_PREFIX_SYMBOLS:
3702 prefix_symbols_string = optarg;
3703 break;
3705 case OPTION_PREFIX_SECTIONS:
3706 prefix_sections_string = optarg;
3707 break;
3709 case OPTION_PREFIX_ALLOC_SECTIONS:
3710 prefix_alloc_sections_string = optarg;
3711 break;
3713 case OPTION_READONLY_TEXT:
3714 bfd_flags_to_set |= WP_TEXT;
3715 bfd_flags_to_clear &= ~WP_TEXT;
3716 break;
3718 case OPTION_WRITABLE_TEXT:
3719 bfd_flags_to_clear |= WP_TEXT;
3720 bfd_flags_to_set &= ~WP_TEXT;
3721 break;
3723 case OPTION_PURE:
3724 bfd_flags_to_set |= D_PAGED;
3725 bfd_flags_to_clear &= ~D_PAGED;
3726 break;
3728 case OPTION_IMPURE:
3729 bfd_flags_to_clear |= D_PAGED;
3730 bfd_flags_to_set &= ~D_PAGED;
3731 break;
3733 case OPTION_EXTRACT_SYMBOL:
3734 extract_symbol = TRUE;
3735 break;
3737 case OPTION_REVERSE_BYTES:
3739 int prev = reverse_bytes;
3741 reverse_bytes = atoi (optarg);
3742 if ((reverse_bytes <= 0) || ((reverse_bytes % 2) != 0))
3743 fatal (_("number of bytes to reverse must be positive and even"));
3745 if (prev && prev != reverse_bytes)
3746 non_fatal (_("Warning: ignoring previous --reverse-bytes value of %d"),
3747 prev);
3748 break;
3751 case OPTION_FILE_ALIGNMENT:
3752 pe_file_alignment = parse_vma (optarg, "--file-alignment");
3753 break;
3755 case OPTION_HEAP:
3757 char *end;
3758 pe_heap_reserve = strtoul (optarg, &end, 0);
3759 if (end == optarg
3760 || (*end != '.' && *end != '\0'))
3761 non_fatal (_("%s: invalid reserve value for --heap"),
3762 optarg);
3763 else if (*end != '\0')
3765 pe_heap_commit = strtoul (end + 1, &end, 0);
3766 if (*end != '\0')
3767 non_fatal (_("%s: invalid commit value for --heap"),
3768 optarg);
3771 break;
3773 case OPTION_IMAGE_BASE:
3774 pe_image_base = parse_vma (optarg, "--image-base");
3775 break;
3777 case OPTION_SECTION_ALIGNMENT:
3778 pe_section_alignment = parse_vma (optarg,
3779 "--section-alignment");
3780 break;
3782 case OPTION_SUBSYSTEM:
3783 set_pe_subsystem (optarg);
3784 break;
3786 case OPTION_STACK:
3788 char *end;
3789 pe_stack_reserve = strtoul (optarg, &end, 0);
3790 if (end == optarg
3791 || (*end != '.' && *end != '\0'))
3792 non_fatal (_("%s: invalid reserve value for --stack"),
3793 optarg);
3794 else if (*end != '\0')
3796 pe_stack_commit = strtoul (end + 1, &end, 0);
3797 if (*end != '\0')
3798 non_fatal (_("%s: invalid commit value for --stack"),
3799 optarg);
3802 break;
3804 case 0:
3805 /* We've been given a long option. */
3806 break;
3808 case 'H':
3809 case 'h':
3810 copy_usage (stdout, 0);
3812 default:
3813 copy_usage (stderr, 1);
3817 if (formats_info)
3819 display_info ();
3820 return 0;
3823 if (show_version)
3824 print_version ("objcopy");
3826 if (interleave && copy_byte == -1)
3827 fatal (_("interleave start byte must be set with --byte"));
3829 if (copy_byte >= interleave)
3830 fatal (_("byte number must be less than interleave"));
3832 if (copy_width > interleave - copy_byte)
3833 fatal (_("interleave width must be less than or equal to interleave - byte`"));
3835 if (optind == argc || optind + 2 < argc)
3836 copy_usage (stderr, 1);
3838 input_filename = argv[optind];
3839 if (optind + 1 < argc)
3840 output_filename = argv[optind + 1];
3842 /* Default is to strip no symbols. */
3843 if (strip_symbols == STRIP_UNDEF && discard_locals == LOCALS_UNDEF)
3844 strip_symbols = STRIP_NONE;
3846 if (output_target == NULL)
3847 output_target = input_target;
3849 /* Convert input EFI target to PEI target. */
3850 if (input_target != NULL
3851 && strncmp (input_target, "efi-", 4) == 0)
3853 char *efi;
3855 efi = xstrdup (output_target + 4);
3856 if (strncmp (efi, "bsdrv-", 6) == 0
3857 || strncmp (efi, "rtdrv-", 6) == 0)
3858 efi += 2;
3859 else if (strncmp (efi, "app-", 4) != 0)
3860 fatal (_("unknown input EFI target: %s"), input_target);
3862 input_target = efi;
3863 convert_efi_target (efi);
3866 /* Convert output EFI target to PEI target. */
3867 if (output_target != NULL
3868 && strncmp (output_target, "efi-", 4) == 0)
3870 char *efi;
3872 efi = xstrdup (output_target + 4);
3873 if (strncmp (efi, "app-", 4) == 0)
3875 if (pe_subsystem == -1)
3876 pe_subsystem = IMAGE_SUBSYSTEM_EFI_APPLICATION;
3878 else if (strncmp (efi, "bsdrv-", 6) == 0)
3880 if (pe_subsystem == -1)
3881 pe_subsystem = IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER;
3882 efi += 2;
3884 else if (strncmp (efi, "rtdrv-", 6) == 0)
3886 if (pe_subsystem == -1)
3887 pe_subsystem = IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER;
3888 efi += 2;
3890 else
3891 fatal (_("unknown output EFI target: %s"), output_target);
3893 if (pe_file_alignment == (bfd_vma) -1)
3894 pe_file_alignment = PE_DEF_FILE_ALIGNMENT;
3895 if (pe_section_alignment == (bfd_vma) -1)
3896 pe_section_alignment = PE_DEF_SECTION_ALIGNMENT;
3898 output_target = efi;
3899 convert_efi_target (efi);
3902 if (preserve_dates)
3903 if (stat (input_filename, & statbuf) < 0)
3904 fatal (_("warning: could not locate '%s'. System error message: %s"),
3905 input_filename, strerror (errno));
3907 /* If there is no destination file, or the source and destination files
3908 are the same, then create a temp and rename the result into the input. */
3909 if (output_filename == NULL
3910 || filename_cmp (input_filename, output_filename) == 0)
3911 tmpname = make_tempname (input_filename);
3912 else
3913 tmpname = output_filename;
3915 if (tmpname == NULL)
3916 fatal (_("warning: could not create temporary file whilst copying '%s', (error: %s)"),
3917 input_filename, strerror (errno));
3919 copy_file (input_filename, tmpname, input_target, output_target, input_arch);
3920 if (status == 0)
3922 if (preserve_dates)
3923 set_times (tmpname, &statbuf);
3924 if (tmpname != output_filename)
3925 status = (smart_rename (tmpname, input_filename,
3926 preserve_dates) != 0);
3928 else
3929 unlink_if_ordinary (tmpname);
3931 if (change_warn)
3933 for (p = change_sections; p != NULL; p = p->next)
3935 if (! p->used)
3937 if (p->change_vma != CHANGE_IGNORE)
3939 char buff [20];
3941 sprintf_vma (buff, p->vma_val);
3943 /* xgettext:c-format */
3944 non_fatal (_("%s %s%c0x%s never used"),
3945 "--change-section-vma",
3946 p->name,
3947 p->change_vma == CHANGE_SET ? '=' : '+',
3948 buff);
3951 if (p->change_lma != CHANGE_IGNORE)
3953 char buff [20];
3955 sprintf_vma (buff, p->lma_val);
3957 /* xgettext:c-format */
3958 non_fatal (_("%s %s%c0x%s never used"),
3959 "--change-section-lma",
3960 p->name,
3961 p->change_lma == CHANGE_SET ? '=' : '+',
3962 buff);
3968 return 0;
3972 main (int argc, char *argv[])
3974 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
3975 setlocale (LC_MESSAGES, "");
3976 #endif
3977 #if defined (HAVE_SETLOCALE)
3978 setlocale (LC_CTYPE, "");
3979 #endif
3980 bindtextdomain (PACKAGE, LOCALEDIR);
3981 textdomain (PACKAGE);
3983 program_name = argv[0];
3984 xmalloc_set_program_name (program_name);
3986 START_PROGRESS (program_name, 0);
3988 expandargv (&argc, &argv);
3990 strip_symbols = STRIP_UNDEF;
3991 discard_locals = LOCALS_UNDEF;
3993 bfd_init ();
3994 set_default_bfd_target ();
3996 if (is_strip < 0)
3998 int i = strlen (program_name);
3999 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
4000 /* Drop the .exe suffix, if any. */
4001 if (i > 4 && FILENAME_CMP (program_name + i - 4, ".exe") == 0)
4003 i -= 4;
4004 program_name[i] = '\0';
4006 #endif
4007 is_strip = (i >= 5 && FILENAME_CMP (program_name + i - 5, "strip") == 0);
4010 create_symbol_htabs ();
4012 if (is_strip)
4013 strip_main (argc, argv);
4014 else
4015 copy_main (argc, argv);
4017 END_PROGRESS (program_name);
4019 return status;