Merge branch 'vendor/GCC50'
[dragonfly.git] / contrib / binutils-2.25 / binutils / objcopy.c
1 /* objcopy.c -- copy object file from input to output, optionally massaging it.
2    Copyright (C) 1991-2014 Free Software Foundation, Inc.
3
4    This file is part of GNU Binutils.
5
6    This program is free software; you can redistribute it and/or modify
7    it under the terms of the GNU General Public License as published by
8    the Free Software Foundation; either version 3 of the License, or
9    (at your option) any later version.
10
11    This program is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14    GNU General Public License for more details.
15
16    You should have received a copy of the GNU General Public License
17    along with this program; if not, write to the Free Software
18    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
19    02110-1301, USA.  */
20 \f
21 #include "sysdep.h"
22 #include "bfd.h"
23 #include "progress.h"
24 #include "getopt.h"
25 #include "libiberty.h"
26 #include "bucomm.h"
27 #include "budbg.h"
28 #include "filenames.h"
29 #include "fnmatch.h"
30 #include "elf-bfd.h"
31 #include "libbfd.h"
32 #include "coff/internal.h"
33 #include "libcoff.h"
34
35 /* FIXME: See bfd/peXXigen.c for why we include an architecture specific
36    header in generic PE code.  */
37 #include "coff/i386.h"
38 #include "coff/pe.h"
39
40 static bfd_vma pe_file_alignment = (bfd_vma) -1;
41 static bfd_vma pe_heap_commit = (bfd_vma) -1;
42 static bfd_vma pe_heap_reserve = (bfd_vma) -1;
43 static bfd_vma pe_image_base = (bfd_vma) -1;
44 static bfd_vma pe_section_alignment = (bfd_vma) -1;
45 static bfd_vma pe_stack_commit = (bfd_vma) -1;
46 static bfd_vma pe_stack_reserve = (bfd_vma) -1;
47 static short pe_subsystem = -1;
48 static short pe_major_subsystem_version = -1;
49 static short pe_minor_subsystem_version = -1;
50
51 struct is_specified_symbol_predicate_data
52 {
53   const char    *name;
54   bfd_boolean   found;
55 };
56
57 /* A list to support redefine_sym.  */
58 struct redefine_node
59 {
60   char *source;
61   char *target;
62   struct redefine_node *next;
63 };
64
65 typedef struct section_rename
66 {
67   const char *            old_name;
68   const char *            new_name;
69   flagword                flags;
70   struct section_rename * next;
71 }
72 section_rename;
73
74 /* List of sections to be renamed.  */
75 static section_rename *section_rename_list;
76
77 static asymbol **isympp = NULL; /* Input symbols.  */
78 static asymbol **osympp = NULL; /* Output symbols that survive stripping.  */
79
80 /* If `copy_byte' >= 0, copy 'copy_width' byte(s) of every `interleave' bytes.  */
81 static int copy_byte = -1;
82 static int interleave = 0; /* Initialised to 4 in copy_main().  */
83 static int copy_width = 1;
84
85 static bfd_boolean verbose;             /* Print file and target names.  */
86 static bfd_boolean preserve_dates;      /* Preserve input file timestamp.  */
87 static int deterministic = -1;          /* Enable deterministic archives.  */
88 static int status = 0;          /* Exit status.  */
89
90 enum strip_action
91   {
92     STRIP_UNDEF,
93     STRIP_NONE,                 /* Don't strip.  */
94     STRIP_DEBUG,                /* Strip all debugger symbols.  */
95     STRIP_UNNEEDED,             /* Strip unnecessary symbols.  */
96     STRIP_NONDEBUG,             /* Strip everything but debug info.  */
97     STRIP_DWO,                  /* Strip all DWO info.  */
98     STRIP_NONDWO,               /* Strip everything but DWO info.  */
99     STRIP_ALL                   /* Strip all symbols.  */
100   };
101
102 /* Which symbols to remove.  */
103 static enum strip_action strip_symbols = STRIP_UNDEF;
104
105 enum locals_action
106   {
107     LOCALS_UNDEF,
108     LOCALS_START_L,             /* Discard locals starting with L.  */
109     LOCALS_ALL                  /* Discard all locals.  */
110   };
111
112 /* Which local symbols to remove.  Overrides STRIP_ALL.  */
113 static enum locals_action discard_locals;
114
115 /* Structure used to hold lists of sections and actions to take.  */
116 struct section_list
117 {
118   struct section_list * next;      /* Next section to change.  */
119   const char *          pattern;   /* Section name pattern.  */
120   bfd_boolean           used;      /* Whether this entry was used.  */
121
122   unsigned int          context;   /* What to do with matching sections.  */
123   /* Flag bits used in the context field.
124      COPY and REMOVE are mutually exlusive.  SET and ALTER are mutually exclusive.  */
125 #define SECTION_CONTEXT_REMOVE    (1 << 0) /* Remove this section.  */
126 #define SECTION_CONTEXT_COPY      (1 << 1) /* Copy this section, delete all non-copied section.  */
127 #define SECTION_CONTEXT_SET_VMA   (1 << 2) /* Set the sections' VMA address.  */
128 #define SECTION_CONTEXT_ALTER_VMA (1 << 3) /* Increment or decrement the section's VMA address.  */
129 #define SECTION_CONTEXT_SET_LMA   (1 << 4) /* Set the sections' LMA address.  */
130 #define SECTION_CONTEXT_ALTER_LMA (1 << 5) /* Increment or decrement the section's LMA address.  */
131 #define SECTION_CONTEXT_SET_FLAGS (1 << 6) /* Set the section's flags.  */
132
133   bfd_vma               vma_val;   /* Amount to change by or set to.  */
134   bfd_vma               lma_val;   /* Amount to change by or set to.  */
135   flagword              flags;     /* What to set the section flags to.  */
136 };
137
138 static struct section_list *change_sections;
139
140 /* TRUE if some sections are to be removed.  */
141 static bfd_boolean sections_removed;
142
143 /* TRUE if only some sections are to be copied.  */
144 static bfd_boolean sections_copied;
145
146 /* Changes to the start address.  */
147 static bfd_vma change_start = 0;
148 static bfd_boolean set_start_set = FALSE;
149 static bfd_vma set_start;
150
151 /* Changes to section addresses.  */
152 static bfd_vma change_section_address = 0;
153
154 /* Filling gaps between sections.  */
155 static bfd_boolean gap_fill_set = FALSE;
156 static bfd_byte gap_fill = 0;
157
158 /* Pad to a given address.  */
159 static bfd_boolean pad_to_set = FALSE;
160 static bfd_vma pad_to;
161
162 /* Use alternative machine code?  */
163 static unsigned long use_alt_mach_code = 0;
164
165 /* Output BFD flags user wants to set or clear */
166 static flagword bfd_flags_to_set;
167 static flagword bfd_flags_to_clear;
168
169 /* List of sections to add.  */
170 struct section_add
171 {
172   /* Next section to add.  */
173   struct section_add *next;
174   /* Name of section to add.  */
175   const char *name;
176   /* Name of file holding section contents.  */
177   const char *filename;
178   /* Size of file.  */
179   size_t size;
180   /* Contents of file.  */
181   bfd_byte *contents;
182   /* BFD section, after it has been added.  */
183   asection *section;
184 };
185
186 /* List of sections to add to the output BFD.  */
187 static struct section_add *add_sections;
188
189 /* List of sections to dump from the output BFD.  */
190 static struct section_add *dump_sections;
191
192 /* If non-NULL the argument to --add-gnu-debuglink.
193    This should be the filename to store in the .gnu_debuglink section.  */
194 static const char * gnu_debuglink_filename = NULL;
195
196 /* Whether to convert debugging information.  */
197 static bfd_boolean convert_debugging = FALSE;
198
199 /* Whether to compress/decompress DWARF debug sections.  */
200 static enum
201 {
202   nothing,
203   compress,
204   decompress
205 } do_debug_sections = nothing;
206
207 /* Whether to change the leading character in symbol names.  */
208 static bfd_boolean change_leading_char = FALSE;
209
210 /* Whether to remove the leading character from global symbol names.  */
211 static bfd_boolean remove_leading_char = FALSE;
212
213 /* Whether to permit wildcard in symbol comparison.  */
214 static bfd_boolean wildcard = FALSE;
215
216 /* True if --localize-hidden is in effect.  */
217 static bfd_boolean localize_hidden = FALSE;
218
219 /* List of symbols to strip, keep, localize, keep-global, weaken,
220    or redefine.  */
221 static htab_t strip_specific_htab = NULL;
222 static htab_t strip_unneeded_htab = NULL;
223 static htab_t keep_specific_htab = NULL;
224 static htab_t localize_specific_htab = NULL;
225 static htab_t globalize_specific_htab = NULL;
226 static htab_t keepglobal_specific_htab = NULL;
227 static htab_t weaken_specific_htab = NULL;
228 static struct redefine_node *redefine_sym_list = NULL;
229
230 /* If this is TRUE, we weaken global symbols (set BSF_WEAK).  */
231 static bfd_boolean weaken = FALSE;
232
233 /* If this is TRUE, we retain BSF_FILE symbols.  */
234 static bfd_boolean keep_file_symbols = FALSE;
235
236 /* Prefix symbols/sections.  */
237 static char *prefix_symbols_string = 0;
238 static char *prefix_sections_string = 0;
239 static char *prefix_alloc_sections_string = 0;
240
241 /* True if --extract-symbol was passed on the command line.  */
242 static bfd_boolean extract_symbol = FALSE;
243
244 /* If `reverse_bytes' is nonzero, then reverse the order of every chunk
245    of <reverse_bytes> bytes within each output section.  */
246 static int reverse_bytes = 0;
247
248 /* For Coff objects, we may want to allow or disallow long section names,
249    or preserve them where found in the inputs.  Debug info relies on them.  */
250 enum long_section_name_handling
251   {
252     DISABLE,
253     ENABLE,
254     KEEP
255   };
256
257 /* The default long section handling mode is to preserve them.
258    This is also the only behaviour for 'strip'.  */
259 static enum long_section_name_handling long_section_names = KEEP;
260
261 /* 150 isn't special; it's just an arbitrary non-ASCII char value.  */
262 enum command_line_switch
263   {
264     OPTION_ADD_SECTION=150,
265     OPTION_DUMP_SECTION,
266     OPTION_CHANGE_ADDRESSES,
267     OPTION_CHANGE_LEADING_CHAR,
268     OPTION_CHANGE_START,
269     OPTION_CHANGE_SECTION_ADDRESS,
270     OPTION_CHANGE_SECTION_LMA,
271     OPTION_CHANGE_SECTION_VMA,
272     OPTION_CHANGE_WARNINGS,
273     OPTION_COMPRESS_DEBUG_SECTIONS,
274     OPTION_DEBUGGING,
275     OPTION_DECOMPRESS_DEBUG_SECTIONS,
276     OPTION_GAP_FILL,
277     OPTION_NO_CHANGE_WARNINGS,
278     OPTION_PAD_TO,
279     OPTION_REMOVE_LEADING_CHAR,
280     OPTION_SET_SECTION_FLAGS,
281     OPTION_SET_START,
282     OPTION_STRIP_UNNEEDED,
283     OPTION_WEAKEN,
284     OPTION_REDEFINE_SYM,
285     OPTION_REDEFINE_SYMS,
286     OPTION_SREC_LEN,
287     OPTION_SREC_FORCES3,
288     OPTION_STRIP_SYMBOLS,
289     OPTION_STRIP_UNNEEDED_SYMBOL,
290     OPTION_STRIP_UNNEEDED_SYMBOLS,
291     OPTION_KEEP_SYMBOLS,
292     OPTION_LOCALIZE_HIDDEN,
293     OPTION_LOCALIZE_SYMBOLS,
294     OPTION_LONG_SECTION_NAMES,
295     OPTION_GLOBALIZE_SYMBOL,
296     OPTION_GLOBALIZE_SYMBOLS,
297     OPTION_KEEPGLOBAL_SYMBOLS,
298     OPTION_WEAKEN_SYMBOLS,
299     OPTION_RENAME_SECTION,
300     OPTION_ALT_MACH_CODE,
301     OPTION_PREFIX_SYMBOLS,
302     OPTION_PREFIX_SECTIONS,
303     OPTION_PREFIX_ALLOC_SECTIONS,
304     OPTION_FORMATS_INFO,
305     OPTION_ADD_GNU_DEBUGLINK,
306     OPTION_ONLY_KEEP_DEBUG,
307     OPTION_KEEP_FILE_SYMBOLS,
308     OPTION_READONLY_TEXT,
309     OPTION_WRITABLE_TEXT,
310     OPTION_PURE,
311     OPTION_IMPURE,
312     OPTION_EXTRACT_SYMBOL,
313     OPTION_REVERSE_BYTES,
314     OPTION_FILE_ALIGNMENT,
315     OPTION_HEAP,
316     OPTION_IMAGE_BASE,
317     OPTION_SECTION_ALIGNMENT,
318     OPTION_STACK,
319     OPTION_INTERLEAVE_WIDTH,
320     OPTION_SUBSYSTEM,
321     OPTION_EXTRACT_DWO,
322     OPTION_STRIP_DWO
323   };
324
325 /* Options to handle if running as "strip".  */
326
327 static struct option strip_options[] =
328 {
329   {"disable-deterministic-archives", no_argument, 0, 'U'},
330   {"discard-all", no_argument, 0, 'x'},
331   {"discard-locals", no_argument, 0, 'X'},
332   {"enable-deterministic-archives", no_argument, 0, 'D'},
333   {"format", required_argument, 0, 'F'}, /* Obsolete */
334   {"help", no_argument, 0, 'h'},
335   {"info", no_argument, 0, OPTION_FORMATS_INFO},
336   {"input-format", required_argument, 0, 'I'}, /* Obsolete */
337   {"input-target", required_argument, 0, 'I'},
338   {"keep-file-symbols", no_argument, 0, OPTION_KEEP_FILE_SYMBOLS},
339   {"keep-symbol", required_argument, 0, 'K'},
340   {"only-keep-debug", no_argument, 0, OPTION_ONLY_KEEP_DEBUG},
341   {"output-format", required_argument, 0, 'O'}, /* Obsolete */
342   {"output-target", required_argument, 0, 'O'},
343   {"output-file", required_argument, 0, 'o'},
344   {"preserve-dates", no_argument, 0, 'p'},
345   {"remove-section", required_argument, 0, 'R'},
346   {"strip-all", no_argument, 0, 's'},
347   {"strip-debug", no_argument, 0, 'S'},
348   {"strip-dwo", no_argument, 0, OPTION_STRIP_DWO},
349   {"strip-unneeded", no_argument, 0, OPTION_STRIP_UNNEEDED},
350   {"strip-symbol", required_argument, 0, 'N'},
351   {"target", required_argument, 0, 'F'},
352   {"verbose", no_argument, 0, 'v'},
353   {"version", no_argument, 0, 'V'},
354   {"wildcard", no_argument, 0, 'w'},
355   {0, no_argument, 0, 0}
356 };
357
358 /* Options to handle if running as "objcopy".  */
359
360 static struct option copy_options[] =
361 {
362   {"add-gnu-debuglink", required_argument, 0, OPTION_ADD_GNU_DEBUGLINK},
363   {"add-section", required_argument, 0, OPTION_ADD_SECTION},
364   {"adjust-start", required_argument, 0, OPTION_CHANGE_START},
365   {"adjust-vma", required_argument, 0, OPTION_CHANGE_ADDRESSES},
366   {"adjust-section-vma", required_argument, 0, OPTION_CHANGE_SECTION_ADDRESS},
367   {"adjust-warnings", no_argument, 0, OPTION_CHANGE_WARNINGS},
368   {"alt-machine-code", required_argument, 0, OPTION_ALT_MACH_CODE},
369   {"binary-architecture", required_argument, 0, 'B'},
370   {"byte", required_argument, 0, 'b'},
371   {"change-addresses", required_argument, 0, OPTION_CHANGE_ADDRESSES},
372   {"change-leading-char", no_argument, 0, OPTION_CHANGE_LEADING_CHAR},
373   {"change-section-address", required_argument, 0, OPTION_CHANGE_SECTION_ADDRESS},
374   {"change-section-lma", required_argument, 0, OPTION_CHANGE_SECTION_LMA},
375   {"change-section-vma", required_argument, 0, OPTION_CHANGE_SECTION_VMA},
376   {"change-start", required_argument, 0, OPTION_CHANGE_START},
377   {"change-warnings", no_argument, 0, OPTION_CHANGE_WARNINGS},
378   {"compress-debug-sections", no_argument, 0, OPTION_COMPRESS_DEBUG_SECTIONS},
379   {"debugging", no_argument, 0, OPTION_DEBUGGING},
380   {"decompress-debug-sections", no_argument, 0, OPTION_DECOMPRESS_DEBUG_SECTIONS},
381   {"disable-deterministic-archives", no_argument, 0, 'U'},
382   {"discard-all", no_argument, 0, 'x'},
383   {"discard-locals", no_argument, 0, 'X'},
384   {"dump-section", required_argument, 0, OPTION_DUMP_SECTION},
385   {"enable-deterministic-archives", no_argument, 0, 'D'},
386   {"extract-dwo", no_argument, 0, OPTION_EXTRACT_DWO},
387   {"extract-symbol", no_argument, 0, OPTION_EXTRACT_SYMBOL},
388   {"format", required_argument, 0, 'F'}, /* Obsolete */
389   {"gap-fill", required_argument, 0, OPTION_GAP_FILL},
390   {"globalize-symbol", required_argument, 0, OPTION_GLOBALIZE_SYMBOL},
391   {"globalize-symbols", required_argument, 0, OPTION_GLOBALIZE_SYMBOLS},
392   {"help", no_argument, 0, 'h'},
393   {"impure", no_argument, 0, OPTION_IMPURE},
394   {"info", no_argument, 0, OPTION_FORMATS_INFO},
395   {"input-format", required_argument, 0, 'I'}, /* Obsolete */
396   {"input-target", required_argument, 0, 'I'},
397   {"interleave", optional_argument, 0, 'i'},
398   {"interleave-width", required_argument, 0, OPTION_INTERLEAVE_WIDTH},
399   {"keep-file-symbols", no_argument, 0, OPTION_KEEP_FILE_SYMBOLS},
400   {"keep-global-symbol", required_argument, 0, 'G'},
401   {"keep-global-symbols", required_argument, 0, OPTION_KEEPGLOBAL_SYMBOLS},
402   {"keep-symbol", required_argument, 0, 'K'},
403   {"keep-symbols", required_argument, 0, OPTION_KEEP_SYMBOLS},
404   {"localize-hidden", no_argument, 0, OPTION_LOCALIZE_HIDDEN},
405   {"localize-symbol", required_argument, 0, 'L'},
406   {"localize-symbols", required_argument, 0, OPTION_LOCALIZE_SYMBOLS},
407   {"long-section-names", required_argument, 0, OPTION_LONG_SECTION_NAMES},
408   {"no-adjust-warnings", no_argument, 0, OPTION_NO_CHANGE_WARNINGS},
409   {"no-change-warnings", no_argument, 0, OPTION_NO_CHANGE_WARNINGS},
410   {"only-keep-debug", no_argument, 0, OPTION_ONLY_KEEP_DEBUG},
411   {"only-section", required_argument, 0, 'j'},
412   {"output-format", required_argument, 0, 'O'}, /* Obsolete */
413   {"output-target", required_argument, 0, 'O'},
414   {"pad-to", required_argument, 0, OPTION_PAD_TO},
415   {"prefix-symbols", required_argument, 0, OPTION_PREFIX_SYMBOLS},
416   {"prefix-sections", required_argument, 0, OPTION_PREFIX_SECTIONS},
417   {"prefix-alloc-sections", required_argument, 0, OPTION_PREFIX_ALLOC_SECTIONS},
418   {"preserve-dates", no_argument, 0, 'p'},
419   {"pure", no_argument, 0, OPTION_PURE},
420   {"readonly-text", no_argument, 0, OPTION_READONLY_TEXT},
421   {"redefine-sym", required_argument, 0, OPTION_REDEFINE_SYM},
422   {"redefine-syms", required_argument, 0, OPTION_REDEFINE_SYMS},
423   {"remove-leading-char", no_argument, 0, OPTION_REMOVE_LEADING_CHAR},
424   {"remove-section", required_argument, 0, 'R'},
425   {"rename-section", required_argument, 0, OPTION_RENAME_SECTION},
426   {"reverse-bytes", required_argument, 0, OPTION_REVERSE_BYTES},
427   {"set-section-flags", required_argument, 0, OPTION_SET_SECTION_FLAGS},
428   {"set-start", required_argument, 0, OPTION_SET_START},
429   {"srec-len", required_argument, 0, OPTION_SREC_LEN},
430   {"srec-forceS3", no_argument, 0, OPTION_SREC_FORCES3},
431   {"strip-all", no_argument, 0, 'S'},
432   {"strip-debug", no_argument, 0, 'g'},
433   {"strip-dwo", no_argument, 0, OPTION_STRIP_DWO},
434   {"strip-unneeded", no_argument, 0, OPTION_STRIP_UNNEEDED},
435   {"strip-unneeded-symbol", required_argument, 0, OPTION_STRIP_UNNEEDED_SYMBOL},
436   {"strip-unneeded-symbols", required_argument, 0, OPTION_STRIP_UNNEEDED_SYMBOLS},
437   {"strip-symbol", required_argument, 0, 'N'},
438   {"strip-symbols", required_argument, 0, OPTION_STRIP_SYMBOLS},
439   {"target", required_argument, 0, 'F'},
440   {"verbose", no_argument, 0, 'v'},
441   {"version", no_argument, 0, 'V'},
442   {"weaken", no_argument, 0, OPTION_WEAKEN},
443   {"weaken-symbol", required_argument, 0, 'W'},
444   {"weaken-symbols", required_argument, 0, OPTION_WEAKEN_SYMBOLS},
445   {"wildcard", no_argument, 0, 'w'},
446   {"writable-text", no_argument, 0, OPTION_WRITABLE_TEXT},
447   {"file-alignment", required_argument, 0, OPTION_FILE_ALIGNMENT},
448   {"heap", required_argument, 0, OPTION_HEAP},
449   {"image-base", required_argument, 0 , OPTION_IMAGE_BASE},
450   {"section-alignment", required_argument, 0, OPTION_SECTION_ALIGNMENT},
451   {"stack", required_argument, 0, OPTION_STACK},
452   {"subsystem", required_argument, 0, OPTION_SUBSYSTEM},
453   {0, no_argument, 0, 0}
454 };
455
456 /* IMPORTS */
457 extern char *program_name;
458
459 /* This flag distinguishes between strip and objcopy:
460    1 means this is 'strip'; 0 means this is 'objcopy'.
461    -1 means if we should use argv[0] to decide.  */
462 extern int is_strip;
463
464 /* The maximum length of an S record.  This variable is declared in srec.c
465    and can be modified by the --srec-len parameter.  */
466 extern unsigned int Chunk;
467
468 /* Restrict the generation of Srecords to type S3 only.
469    This variable is declare in bfd/srec.c and can be toggled
470    on by the --srec-forceS3 command line switch.  */
471 extern bfd_boolean S3Forced;
472
473 /* Forward declarations.  */
474 static void setup_section (bfd *, asection *, void *);
475 static void setup_bfd_headers (bfd *, bfd *);
476 static void copy_relocations_in_section (bfd *, asection *, void *);
477 static void copy_section (bfd *, asection *, void *);
478 static void get_sections (bfd *, asection *, void *);
479 static int compare_section_lma (const void *, const void *);
480 static void mark_symbols_used_in_relocations (bfd *, asection *, void *);
481 static bfd_boolean write_debugging_info (bfd *, void *, long *, asymbol ***);
482 static const char *lookup_sym_redefinition (const char *);
483 \f
484 static void
485 copy_usage (FILE *stream, int exit_status)
486 {
487   fprintf (stream, _("Usage: %s [option(s)] in-file [out-file]\n"), program_name);
488   fprintf (stream, _(" Copies a binary file, possibly transforming it in the process\n"));
489   fprintf (stream, _(" The options are:\n"));
490   fprintf (stream, _("\
491   -I --input-target <bfdname>      Assume input file is in format <bfdname>\n\
492   -O --output-target <bfdname>     Create an output file in format <bfdname>\n\
493   -B --binary-architecture <arch>  Set output arch, when input is arch-less\n\
494   -F --target <bfdname>            Set both input and output format to <bfdname>\n\
495      --debugging                   Convert debugging information, if possible\n\
496   -p --preserve-dates              Copy modified/access timestamps to the output\n"));
497   if (DEFAULT_AR_DETERMINISTIC)
498     fprintf (stream, _("\
499   -D --enable-deterministic-archives\n\
500                                    Produce deterministic output when stripping archives (default)\n\
501   -U --disable-deterministic-archives\n\
502                                    Disable -D behavior\n"));
503   else
504     fprintf (stream, _("\
505   -D --enable-deterministic-archives\n\
506                                    Produce deterministic output when stripping archives\n\
507   -U --disable-deterministic-archives\n\
508                                    Disable -D behavior (default)\n"));
509   fprintf (stream, _("\
510   -j --only-section <name>         Only copy section <name> into the output\n\
511      --add-gnu-debuglink=<file>    Add section .gnu_debuglink linking to <file>\n\
512   -R --remove-section <name>       Remove section <name> from the output\n\
513   -S --strip-all                   Remove all symbol and relocation information\n\
514   -g --strip-debug                 Remove all debugging symbols & sections\n\
515      --strip-dwo                   Remove all DWO sections\n\
516      --strip-unneeded              Remove all symbols not needed by relocations\n\
517   -N --strip-symbol <name>         Do not copy symbol <name>\n\
518      --strip-unneeded-symbol <name>\n\
519                                    Do not copy symbol <name> unless needed by\n\
520                                      relocations\n\
521      --only-keep-debug             Strip everything but the debug information\n\
522      --extract-dwo                 Copy only DWO sections\n\
523      --extract-symbol              Remove section contents but keep symbols\n\
524   -K --keep-symbol <name>          Do not strip symbol <name>\n\
525      --keep-file-symbols           Do not strip file symbol(s)\n\
526      --localize-hidden             Turn all ELF hidden symbols into locals\n\
527   -L --localize-symbol <name>      Force symbol <name> to be marked as a local\n\
528      --globalize-symbol <name>     Force symbol <name> to be marked as a global\n\
529   -G --keep-global-symbol <name>   Localize all symbols except <name>\n\
530   -W --weaken-symbol <name>        Force symbol <name> to be marked as a weak\n\
531      --weaken                      Force all global symbols to be marked as weak\n\
532   -w --wildcard                    Permit wildcard in symbol comparison\n\
533   -x --discard-all                 Remove all non-global symbols\n\
534   -X --discard-locals              Remove any compiler-generated symbols\n\
535   -i --interleave [<number>]       Only copy N out of every <number> bytes\n\
536      --interleave-width <number>   Set N for --interleave\n\
537   -b --byte <num>                  Select byte <num> in every interleaved block\n\
538      --gap-fill <val>              Fill gaps between sections with <val>\n\
539      --pad-to <addr>               Pad the last section up to address <addr>\n\
540      --set-start <addr>            Set the start address to <addr>\n\
541     {--change-start|--adjust-start} <incr>\n\
542                                    Add <incr> to the start address\n\
543     {--change-addresses|--adjust-vma} <incr>\n\
544                                    Add <incr> to LMA, VMA and start addresses\n\
545     {--change-section-address|--adjust-section-vma} <name>{=|+|-}<val>\n\
546                                    Change LMA and VMA of section <name> by <val>\n\
547      --change-section-lma <name>{=|+|-}<val>\n\
548                                    Change the LMA of section <name> by <val>\n\
549      --change-section-vma <name>{=|+|-}<val>\n\
550                                    Change the VMA of section <name> by <val>\n\
551     {--[no-]change-warnings|--[no-]adjust-warnings}\n\
552                                    Warn if a named section does not exist\n\
553      --set-section-flags <name>=<flags>\n\
554                                    Set section <name>'s properties to <flags>\n\
555      --add-section <name>=<file>   Add section <name> found in <file> to output\n\
556      --dump-section <name>=<file>  Dump the contents of section <name> into <file>\n\
557      --rename-section <old>=<new>[,<flags>] Rename section <old> to <new>\n\
558      --long-section-names {enable|disable|keep}\n\
559                                    Handle long section names in Coff objects.\n\
560      --change-leading-char         Force output format's leading character style\n\
561      --remove-leading-char         Remove leading character from global symbols\n\
562      --reverse-bytes=<num>         Reverse <num> bytes at a time, in output sections with content\n\
563      --redefine-sym <old>=<new>    Redefine symbol name <old> to <new>\n\
564      --redefine-syms <file>        --redefine-sym for all symbol pairs \n\
565                                      listed in <file>\n\
566      --srec-len <number>           Restrict the length of generated Srecords\n\
567      --srec-forceS3                Restrict the type of generated Srecords to S3\n\
568      --strip-symbols <file>        -N for all symbols listed in <file>\n\
569      --strip-unneeded-symbols <file>\n\
570                                    --strip-unneeded-symbol for all symbols listed\n\
571                                      in <file>\n\
572      --keep-symbols <file>         -K for all symbols listed in <file>\n\
573      --localize-symbols <file>     -L for all symbols listed in <file>\n\
574      --globalize-symbols <file>    --globalize-symbol for all in <file>\n\
575      --keep-global-symbols <file>  -G for all symbols listed in <file>\n\
576      --weaken-symbols <file>       -W for all symbols listed in <file>\n\
577      --alt-machine-code <index>    Use the target's <index>'th alternative machine\n\
578      --writable-text               Mark the output text as writable\n\
579      --readonly-text               Make the output text write protected\n\
580      --pure                        Mark the output file as demand paged\n\
581      --impure                      Mark the output file as impure\n\
582      --prefix-symbols <prefix>     Add <prefix> to start of every symbol name\n\
583      --prefix-sections <prefix>    Add <prefix> to start of every section name\n\
584      --prefix-alloc-sections <prefix>\n\
585                                    Add <prefix> to start of every allocatable\n\
586                                      section name\n\
587      --file-alignment <num>        Set PE file alignment to <num>\n\
588      --heap <reserve>[,<commit>]   Set PE reserve/commit heap to <reserve>/\n\
589                                    <commit>\n\
590      --image-base <address>        Set PE image base to <address>\n\
591      --section-alignment <num>     Set PE section alignment to <num>\n\
592      --stack <reserve>[,<commit>]  Set PE reserve/commit stack to <reserve>/\n\
593                                    <commit>\n\
594      --subsystem <name>[:<version>]\n\
595                                    Set PE subsystem to <name> [& <version>]\n\
596      --compress-debug-sections     Compress DWARF debug sections using zlib\n\
597      --decompress-debug-sections   Decompress DWARF debug sections using zlib\n\
598   -v --verbose                     List all object files modified\n\
599   @<file>                          Read options from <file>\n\
600   -V --version                     Display this program's version number\n\
601   -h --help                        Display this output\n\
602      --info                        List object formats & architectures supported\n\
603 "));
604   list_supported_targets (program_name, stream);
605   if (REPORT_BUGS_TO[0] && exit_status == 0)
606     fprintf (stream, _("Report bugs to %s\n"), REPORT_BUGS_TO);
607   exit (exit_status);
608 }
609
610 static void
611 strip_usage (FILE *stream, int exit_status)
612 {
613   fprintf (stream, _("Usage: %s <option(s)> in-file(s)\n"), program_name);
614   fprintf (stream, _(" Removes symbols and sections from files\n"));
615   fprintf (stream, _(" The options are:\n"));
616   fprintf (stream, _("\
617   -I --input-target=<bfdname>      Assume input file is in format <bfdname>\n\
618   -O --output-target=<bfdname>     Create an output file in format <bfdname>\n\
619   -F --target=<bfdname>            Set both input and output format to <bfdname>\n\
620   -p --preserve-dates              Copy modified/access timestamps to the output\n\
621 "));
622   if (DEFAULT_AR_DETERMINISTIC)
623     fprintf (stream, _("\
624   -D --enable-deterministic-archives\n\
625                                    Produce deterministic output when stripping archives (default)\n\
626   -U --disable-deterministic-archives\n\
627                                    Disable -D behavior\n"));
628   else
629     fprintf (stream, _("\
630   -D --enable-deterministic-archives\n\
631                                    Produce deterministic output when stripping archives\n\
632   -U --disable-deterministic-archives\n\
633                                    Disable -D behavior (default)\n"));
634   fprintf (stream, _("\
635   -R --remove-section=<name>       Remove section <name> from the output\n\
636   -s --strip-all                   Remove all symbol and relocation information\n\
637   -g -S -d --strip-debug           Remove all debugging symbols & sections\n\
638      --strip-dwo                   Remove all DWO sections\n\
639      --strip-unneeded              Remove all symbols not needed by relocations\n\
640      --only-keep-debug             Strip everything but the debug information\n\
641   -N --strip-symbol=<name>         Do not copy symbol <name>\n\
642   -K --keep-symbol=<name>          Do not strip symbol <name>\n\
643      --keep-file-symbols           Do not strip file symbol(s)\n\
644   -w --wildcard                    Permit wildcard in symbol comparison\n\
645   -x --discard-all                 Remove all non-global symbols\n\
646   -X --discard-locals              Remove any compiler-generated symbols\n\
647   -v --verbose                     List all object files modified\n\
648   -V --version                     Display this program's version number\n\
649   -h --help                        Display this output\n\
650      --info                        List object formats & architectures supported\n\
651   -o <file>                        Place stripped output into <file>\n\
652 "));
653
654   list_supported_targets (program_name, stream);
655   if (REPORT_BUGS_TO[0] && exit_status == 0)
656     fprintf (stream, _("Report bugs to %s\n"), REPORT_BUGS_TO);
657   exit (exit_status);
658 }
659
660 /* Parse section flags into a flagword, with a fatal error if the
661    string can't be parsed.  */
662
663 static flagword
664 parse_flags (const char *s)
665 {
666   flagword ret;
667   const char *snext;
668   int len;
669
670   ret = SEC_NO_FLAGS;
671
672   do
673     {
674       snext = strchr (s, ',');
675       if (snext == NULL)
676         len = strlen (s);
677       else
678         {
679           len = snext - s;
680           ++snext;
681         }
682
683       if (0) ;
684 #define PARSE_FLAG(fname,fval) \
685   else if (strncasecmp (fname, s, len) == 0) ret |= fval
686       PARSE_FLAG ("alloc", SEC_ALLOC);
687       PARSE_FLAG ("load", SEC_LOAD);
688       PARSE_FLAG ("noload", SEC_NEVER_LOAD);
689       PARSE_FLAG ("readonly", SEC_READONLY);
690       PARSE_FLAG ("debug", SEC_DEBUGGING);
691       PARSE_FLAG ("code", SEC_CODE);
692       PARSE_FLAG ("data", SEC_DATA);
693       PARSE_FLAG ("rom", SEC_ROM);
694       PARSE_FLAG ("share", SEC_COFF_SHARED);
695       PARSE_FLAG ("contents", SEC_HAS_CONTENTS);
696       PARSE_FLAG ("merge", SEC_MERGE);
697       PARSE_FLAG ("strings", SEC_STRINGS);
698 #undef PARSE_FLAG
699       else
700         {
701           char *copy;
702
703           copy = (char *) xmalloc (len + 1);
704           strncpy (copy, s, len);
705           copy[len] = '\0';
706           non_fatal (_("unrecognized section flag `%s'"), copy);
707           fatal (_("supported flags: %s"),
708                  "alloc, load, noload, readonly, debug, code, data, rom, share, contents, merge, strings");
709         }
710
711       s = snext;
712     }
713   while (s != NULL);
714
715   return ret;
716 }
717
718 /* Find and optionally add an entry in the change_sections list.
719
720    We need to be careful in how we match section names because of the support
721    for wildcard characters.  For example suppose that the user has invoked
722    objcopy like this:
723          
724        --set-section-flags .debug_*=debug
725        --set-section-flags .debug_str=readonly,debug
726        --change-section-address .debug_*ranges=0x1000
727
728    With the idea that all debug sections will receive the DEBUG flag, the
729    .debug_str section will also receive the READONLY flag and the
730    .debug_ranges and .debug_aranges sections will have their address set to
731    0x1000.  (This may not make much sense, but it is just an example).
732
733    When adding the section name patterns to the section list we need to make
734    sure that previous entries do not match with the new entry, unless the
735    match is exact.  (In which case we assume that the user is overriding
736    the previous entry with the new context).
737
738    When matching real section names to the section list we make use of the
739    wildcard characters, but we must do so in context.  Eg if we are setting
740    section addresses then we match for .debug_ranges but not for .debug_info.
741
742    Finally, if ADD is false and we do find a match, we mark the section list
743    entry as used.  */
744
745 static struct section_list *
746 find_section_list (const char *name, bfd_boolean add, unsigned int context)
747 {
748   struct section_list *p;
749
750   /* assert ((context & ((1 << 7) - 1)) != 0); */
751   
752   for (p = change_sections; p != NULL; p = p->next)
753     {
754       if (add)
755         {
756           if (strcmp (p->pattern, name) == 0)
757             {
758               /* Check for context conflicts.  */
759               if (((p->context & SECTION_CONTEXT_REMOVE)
760                    && (context & SECTION_CONTEXT_COPY))
761                   || ((context & SECTION_CONTEXT_REMOVE)
762                       && (p->context & SECTION_CONTEXT_COPY)))
763                 fatal (_("error: %s both copied and removed"), name);
764
765               if (((p->context & SECTION_CONTEXT_SET_VMA)
766                   && (context & SECTION_CONTEXT_ALTER_VMA))
767                   || ((context & SECTION_CONTEXT_SET_VMA)
768                       && (context & SECTION_CONTEXT_ALTER_VMA)))
769                 fatal (_("error: %s both sets and alters VMA"), name);
770
771               if (((p->context & SECTION_CONTEXT_SET_LMA)
772                   && (context & SECTION_CONTEXT_ALTER_LMA))
773                   || ((context & SECTION_CONTEXT_SET_LMA)
774                       && (context & SECTION_CONTEXT_ALTER_LMA)))
775                 fatal (_("error: %s both sets and alters LMA"), name);
776
777               /* Extend the context.  */
778               p->context |= context;
779               return p;
780             }
781         }
782       /* If we are not adding a new name/pattern then
783          only check for a match if the context applies.  */
784       else if ((p->context & context)
785                /* We could check for the presence of wildchar characters
786                   first and choose between calling strcmp and fnmatch,
787                   but is that really worth it ?  */
788                && fnmatch (p->pattern, name, 0) == 0)
789         {
790           p->used = TRUE;
791           return p;
792         }
793     }
794
795   if (! add)
796     return NULL;
797
798   p = (struct section_list *) xmalloc (sizeof (struct section_list));
799   p->pattern = name;
800   p->used = FALSE;
801   p->context = context;
802   p->vma_val = 0;
803   p->lma_val = 0;
804   p->flags = 0;
805   p->next = change_sections;
806   change_sections = p;
807
808   return p;
809 }
810
811 /* There is htab_hash_string but no htab_eq_string. Makes sense.  */
812
813 static int
814 eq_string (const void *s1, const void *s2)
815 {
816   return strcmp ((const char *) s1, (const char *) s2) == 0;
817 }
818
819 static htab_t
820 create_symbol_htab (void)
821 {
822   return htab_create_alloc (16, htab_hash_string, eq_string, NULL, xcalloc, free);
823 }
824
825 static void
826 create_symbol_htabs (void)
827 {
828   strip_specific_htab = create_symbol_htab ();
829   strip_unneeded_htab = create_symbol_htab ();
830   keep_specific_htab = create_symbol_htab ();
831   localize_specific_htab = create_symbol_htab ();
832   globalize_specific_htab = create_symbol_htab ();
833   keepglobal_specific_htab = create_symbol_htab ();
834   weaken_specific_htab = create_symbol_htab ();
835 }
836
837 /* Add a symbol to strip_specific_list.  */
838
839 static void
840 add_specific_symbol (const char *name, htab_t htab)
841 {
842   *htab_find_slot (htab, name, INSERT) = (char *) name;
843 }
844
845 /* Add symbols listed in `filename' to strip_specific_list.  */
846
847 #define IS_WHITESPACE(c)      ((c) == ' ' || (c) == '\t')
848 #define IS_LINE_TERMINATOR(c) ((c) == '\n' || (c) == '\r' || (c) == '\0')
849
850 static void
851 add_specific_symbols (const char *filename, htab_t htab)
852 {
853   off_t  size;
854   FILE * f;
855   char * line;
856   char * buffer;
857   unsigned int line_count;
858
859   size = get_file_size (filename);
860   if (size == 0)
861     {
862       status = 1;
863       return;
864     }
865
866   buffer = (char *) xmalloc (size + 2);
867   f = fopen (filename, FOPEN_RT);
868   if (f == NULL)
869     fatal (_("cannot open '%s': %s"), filename, strerror (errno));
870
871   if (fread (buffer, 1, size, f) == 0 || ferror (f))
872     fatal (_("%s: fread failed"), filename);
873
874   fclose (f);
875   buffer [size] = '\n';
876   buffer [size + 1] = '\0';
877
878   line_count = 1;
879
880   for (line = buffer; * line != '\0'; line ++)
881     {
882       char * eol;
883       char * name;
884       char * name_end;
885       int finished = FALSE;
886
887       for (eol = line;; eol ++)
888         {
889           switch (* eol)
890             {
891             case '\n':
892               * eol = '\0';
893               /* Cope with \n\r.  */
894               if (eol[1] == '\r')
895                 ++ eol;
896               finished = TRUE;
897               break;
898
899             case '\r':
900               * eol = '\0';
901               /* Cope with \r\n.  */
902               if (eol[1] == '\n')
903                 ++ eol;
904               finished = TRUE;
905               break;
906
907             case 0:
908               finished = TRUE;
909               break;
910
911             case '#':
912               /* Line comment, Terminate the line here, in case a
913                  name is present and then allow the rest of the
914                  loop to find the real end of the line.  */
915               * eol = '\0';
916               break;
917
918             default:
919               break;
920             }
921
922           if (finished)
923             break;
924         }
925
926       /* A name may now exist somewhere between 'line' and 'eol'.
927          Strip off leading whitespace and trailing whitespace,
928          then add it to the list.  */
929       for (name = line; IS_WHITESPACE (* name); name ++)
930         ;
931       for (name_end = name;
932            (! IS_WHITESPACE (* name_end))
933            && (! IS_LINE_TERMINATOR (* name_end));
934            name_end ++)
935         ;
936
937       if (! IS_LINE_TERMINATOR (* name_end))
938         {
939           char * extra;
940
941           for (extra = name_end + 1; IS_WHITESPACE (* extra); extra ++)
942             ;
943
944           if (! IS_LINE_TERMINATOR (* extra))
945             non_fatal (_("%s:%d: Ignoring rubbish found on this line"),
946                        filename, line_count);
947         }
948
949       * name_end = '\0';
950
951       if (name_end > name)
952         add_specific_symbol (name, htab);
953
954       /* Advance line pointer to end of line.  The 'eol ++' in the for
955          loop above will then advance us to the start of the next line.  */
956       line = eol;
957       line_count ++;
958     }
959 }
960
961 /* See whether a symbol should be stripped or kept
962    based on strip_specific_list and keep_symbols.  */
963
964 static int
965 is_specified_symbol_predicate (void **slot, void *data)
966 {
967   struct is_specified_symbol_predicate_data *d =
968       (struct is_specified_symbol_predicate_data *) data;
969   const char *slot_name = (char *) *slot;
970
971   if (*slot_name != '!')
972     {
973       if (! fnmatch (slot_name, d->name, 0))
974         {
975           d->found = TRUE;
976           /* Stop traversal.  */
977           return 0;
978         }
979     }
980   else
981     {
982       if (fnmatch (slot_name + 1, d->name, 0))
983         {
984           d->found = TRUE;
985           /* Stop traversal.  */
986           return 0;
987         }
988     }
989
990   /* Continue traversal.  */
991   return 1;
992 }
993
994 static bfd_boolean
995 is_specified_symbol (const char *name, htab_t htab)
996 {
997   if (wildcard)
998     {
999       struct is_specified_symbol_predicate_data data;
1000
1001       data.name = name;
1002       data.found = FALSE;
1003
1004       htab_traverse (htab, is_specified_symbol_predicate, &data);
1005
1006       return data.found;
1007     }
1008
1009   return htab_find (htab, name) != NULL;
1010 }
1011
1012 /* Return a pointer to the symbol used as a signature for GROUP.  */
1013
1014 static asymbol *
1015 group_signature (asection *group)
1016 {
1017   bfd *abfd = group->owner;
1018   Elf_Internal_Shdr *ghdr;
1019
1020   if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
1021     return NULL;
1022
1023   ghdr = &elf_section_data (group)->this_hdr;
1024   if (ghdr->sh_link < elf_numsections (abfd))
1025     {
1026       const struct elf_backend_data *bed = get_elf_backend_data (abfd);
1027       Elf_Internal_Shdr *symhdr = elf_elfsections (abfd) [ghdr->sh_link];
1028
1029       if (symhdr->sh_type == SHT_SYMTAB
1030           && ghdr->sh_info < symhdr->sh_size / bed->s->sizeof_sym)
1031         return isympp[ghdr->sh_info - 1];
1032     }
1033   return NULL;
1034 }
1035
1036 /* Return TRUE if the section is a DWO section.  */
1037
1038 static bfd_boolean
1039 is_dwo_section (bfd *abfd ATTRIBUTE_UNUSED, asection *sec)
1040 {
1041   const char *name = bfd_get_section_name (abfd, sec);
1042   int len = strlen (name);
1043
1044   return strncmp (name + len - 4, ".dwo", 4) == 0;
1045 }
1046
1047 /* See if a non-group section is being removed.  */
1048
1049 static bfd_boolean
1050 is_strip_section_1 (bfd *abfd ATTRIBUTE_UNUSED, asection *sec)
1051 {
1052   if (sections_removed || sections_copied)
1053     {
1054       struct section_list *p;
1055       struct section_list *q;
1056
1057       p = find_section_list (bfd_get_section_name (abfd, sec), FALSE,
1058                              SECTION_CONTEXT_REMOVE);
1059       q = find_section_list (bfd_get_section_name (abfd, sec), FALSE,
1060                              SECTION_CONTEXT_COPY);
1061
1062       if (p && q)
1063         fatal (_("error: section %s matches both remove and copy options"),
1064                bfd_get_section_name (abfd, sec));
1065
1066       if (p != NULL)
1067         return TRUE;
1068       if (sections_copied && q == NULL)
1069         return TRUE;
1070     }
1071
1072   if ((bfd_get_section_flags (abfd, sec) & SEC_DEBUGGING) != 0)
1073     {
1074       if (strip_symbols == STRIP_DEBUG
1075           || strip_symbols == STRIP_UNNEEDED
1076           || strip_symbols == STRIP_ALL
1077           || discard_locals == LOCALS_ALL
1078           || convert_debugging)
1079         {
1080           /* By default we don't want to strip .reloc section.
1081              This section has for pe-coff special meaning.   See
1082              pe-dll.c file in ld, and peXXigen.c in bfd for details.  */
1083           if (strcmp (bfd_get_section_name (abfd, sec), ".reloc") != 0)
1084             return TRUE;
1085         }
1086
1087       if (strip_symbols == STRIP_DWO)
1088         return is_dwo_section (abfd, sec);
1089
1090       if (strip_symbols == STRIP_NONDEBUG)
1091         return FALSE;
1092     }
1093
1094   if (strip_symbols == STRIP_NONDWO)
1095     return !is_dwo_section (abfd, sec);
1096
1097   return FALSE;
1098 }
1099
1100 /* See if a section is being removed.  */
1101
1102 static bfd_boolean
1103 is_strip_section (bfd *abfd ATTRIBUTE_UNUSED, asection *sec)
1104 {
1105   if (is_strip_section_1 (abfd, sec))
1106     return TRUE;
1107
1108   if ((bfd_get_section_flags (abfd, sec) & SEC_GROUP) != 0)
1109     {
1110       asymbol *gsym;
1111       const char *gname;
1112       asection *elt, *first;
1113
1114       /* PR binutils/3181
1115          If we are going to strip the group signature symbol, then
1116          strip the group section too.  */
1117       gsym = group_signature (sec);
1118       if (gsym != NULL)
1119         gname = gsym->name;
1120       else
1121         gname = sec->name;
1122       if ((strip_symbols == STRIP_ALL
1123            && !is_specified_symbol (gname, keep_specific_htab))
1124           || is_specified_symbol (gname, strip_specific_htab))
1125         return TRUE;
1126
1127       /* Remove the group section if all members are removed.  */
1128       first = elt = elf_next_in_group (sec);
1129       while (elt != NULL)
1130         {
1131           if (!is_strip_section_1 (abfd, elt))
1132             return FALSE;
1133           elt = elf_next_in_group (elt);
1134           if (elt == first)
1135             break;
1136         }
1137
1138       return TRUE;
1139     }
1140
1141   return FALSE;
1142 }
1143
1144 static bfd_boolean
1145 is_nondebug_keep_contents_section (bfd *ibfd, asection *isection)
1146 {
1147   /* Always keep ELF note sections.  */
1148   if (ibfd->xvec->flavour == bfd_target_elf_flavour)
1149     return (elf_section_type (isection) == SHT_NOTE);
1150
1151   /* Always keep the .buildid section for PE/COFF.
1152
1153      Strictly, this should be written "always keep the section storing the debug
1154      directory", but that may be the .text section for objects produced by some
1155      tools, which it is not sensible to keep.  */
1156   if (ibfd->xvec->flavour == bfd_target_coff_flavour)
1157     return (strcmp (bfd_get_section_name (ibfd, isection), ".buildid") == 0);
1158
1159   return FALSE;
1160 }
1161
1162 /* Return true if SYM is a hidden symbol.  */
1163
1164 static bfd_boolean
1165 is_hidden_symbol (asymbol *sym)
1166 {
1167   elf_symbol_type *elf_sym;
1168
1169   elf_sym = elf_symbol_from (sym->the_bfd, sym);
1170   if (elf_sym != NULL)
1171     switch (ELF_ST_VISIBILITY (elf_sym->internal_elf_sym.st_other))
1172       {
1173       case STV_HIDDEN:
1174       case STV_INTERNAL:
1175         return TRUE;
1176       }
1177   return FALSE;
1178 }
1179
1180 /* Choose which symbol entries to copy; put the result in OSYMS.
1181    We don't copy in place, because that confuses the relocs.
1182    Return the number of symbols to print.  */
1183
1184 static unsigned int
1185 filter_symbols (bfd *abfd, bfd *obfd, asymbol **osyms,
1186                 asymbol **isyms, long symcount)
1187 {
1188   asymbol **from = isyms, **to = osyms;
1189   long src_count = 0, dst_count = 0;
1190   int relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
1191
1192   for (; src_count < symcount; src_count++)
1193     {
1194       asymbol *sym = from[src_count];
1195       flagword flags = sym->flags;
1196       char *name = (char *) bfd_asymbol_name (sym);
1197       bfd_boolean keep;
1198       bfd_boolean used_in_reloc = FALSE;
1199       bfd_boolean undefined;
1200       bfd_boolean rem_leading_char;
1201       bfd_boolean add_leading_char;
1202
1203       undefined = bfd_is_und_section (bfd_get_section (sym));
1204
1205       if (redefine_sym_list)
1206         {
1207           char *old_name, *new_name;
1208
1209           old_name = (char *) bfd_asymbol_name (sym);
1210           new_name = (char *) lookup_sym_redefinition (old_name);
1211           bfd_asymbol_name (sym) = new_name;
1212           name = new_name;
1213         }
1214
1215       /* Check if we will remove the current leading character.  */
1216       rem_leading_char =
1217         (name[0] == bfd_get_symbol_leading_char (abfd))
1218         && (change_leading_char
1219             || (remove_leading_char
1220                 && ((flags & (BSF_GLOBAL | BSF_WEAK)) != 0
1221                     || undefined
1222                     || bfd_is_com_section (bfd_get_section (sym)))));
1223
1224       /* Check if we will add a new leading character.  */
1225       add_leading_char =
1226         change_leading_char
1227         && (bfd_get_symbol_leading_char (obfd) != '\0')
1228         && (bfd_get_symbol_leading_char (abfd) == '\0'
1229             || (name[0] == bfd_get_symbol_leading_char (abfd)));
1230
1231       /* Short circuit for change_leading_char if we can do it in-place.  */
1232       if (rem_leading_char && add_leading_char && !prefix_symbols_string)
1233         {
1234           name[0] = bfd_get_symbol_leading_char (obfd);
1235           bfd_asymbol_name (sym) = name;
1236           rem_leading_char = FALSE;
1237           add_leading_char = FALSE;
1238         }
1239
1240       /* Remove leading char.  */
1241       if (rem_leading_char)
1242         bfd_asymbol_name (sym) = ++name;
1243
1244       /* Add new leading char and/or prefix.  */
1245       if (add_leading_char || prefix_symbols_string)
1246         {
1247           char *n, *ptr;
1248
1249           ptr = n = (char *) xmalloc (1 + strlen (prefix_symbols_string)
1250                                       + strlen (name) + 1);
1251           if (add_leading_char)
1252             *ptr++ = bfd_get_symbol_leading_char (obfd);
1253
1254           if (prefix_symbols_string)
1255             {
1256               strcpy (ptr, prefix_symbols_string);
1257               ptr += strlen (prefix_symbols_string);
1258            }
1259
1260           strcpy (ptr, name);
1261           bfd_asymbol_name (sym) = n;
1262           name = n;
1263         }
1264
1265       if (strip_symbols == STRIP_ALL)
1266         keep = FALSE;
1267       else if ((flags & BSF_KEEP) != 0          /* Used in relocation.  */
1268                || ((flags & BSF_SECTION_SYM) != 0
1269                    && ((*bfd_get_section (sym)->symbol_ptr_ptr)->flags
1270                        & BSF_KEEP) != 0))
1271         {
1272           keep = TRUE;
1273           used_in_reloc = TRUE;
1274         }
1275       else if (relocatable                      /* Relocatable file.  */
1276                && ((flags & (BSF_GLOBAL | BSF_WEAK)) != 0
1277                    || bfd_is_com_section (bfd_get_section (sym))))
1278         keep = TRUE;
1279       else if (bfd_decode_symclass (sym) == 'I')
1280         /* Global symbols in $idata sections need to be retained
1281            even if relocatable is FALSE.  External users of the
1282            library containing the $idata section may reference these
1283            symbols.  */
1284         keep = TRUE;
1285       else if ((flags & BSF_GLOBAL) != 0        /* Global symbol.  */
1286                || (flags & BSF_WEAK) != 0
1287                || undefined
1288                || bfd_is_com_section (bfd_get_section (sym)))
1289         keep = strip_symbols != STRIP_UNNEEDED;
1290       else if ((flags & BSF_DEBUGGING) != 0)    /* Debugging symbol.  */
1291         keep = (strip_symbols != STRIP_DEBUG
1292                 && strip_symbols != STRIP_UNNEEDED
1293                 && ! convert_debugging);
1294       else if (bfd_coff_get_comdat_section (abfd, bfd_get_section (sym)))
1295         /* COMDAT sections store special information in local
1296            symbols, so we cannot risk stripping any of them.  */
1297         keep = TRUE;
1298       else                      /* Local symbol.  */
1299         keep = (strip_symbols != STRIP_UNNEEDED
1300                 && (discard_locals != LOCALS_ALL
1301                     && (discard_locals != LOCALS_START_L
1302                         || ! bfd_is_local_label (abfd, sym))));
1303
1304       if (keep && is_specified_symbol (name, strip_specific_htab))
1305         {
1306           /* There are multiple ways to set 'keep' above, but if it
1307              was the relocatable symbol case, then that's an error.  */
1308           if (used_in_reloc)
1309             {
1310               non_fatal (_("not stripping symbol `%s' because it is named in a relocation"), name);
1311               status = 1;
1312             }
1313           else
1314             keep = FALSE;
1315         }
1316
1317       if (keep
1318           && !(flags & BSF_KEEP)
1319           && is_specified_symbol (name, strip_unneeded_htab))
1320         keep = FALSE;
1321
1322       if (!keep
1323           && ((keep_file_symbols && (flags & BSF_FILE))
1324               || is_specified_symbol (name, keep_specific_htab)))
1325         keep = TRUE;
1326
1327       if (keep && is_strip_section (abfd, bfd_get_section (sym)))
1328         keep = FALSE;
1329
1330       if (keep)
1331         {
1332           if ((flags & BSF_GLOBAL) != 0
1333               && (weaken || is_specified_symbol (name, weaken_specific_htab)))
1334             {
1335               sym->flags &= ~ BSF_GLOBAL;
1336               sym->flags |= BSF_WEAK;
1337             }
1338
1339           if (!undefined
1340               && (flags & (BSF_GLOBAL | BSF_WEAK))
1341               && (is_specified_symbol (name, localize_specific_htab)
1342                   || (htab_elements (keepglobal_specific_htab) != 0
1343                       && ! is_specified_symbol (name, keepglobal_specific_htab))
1344                   || (localize_hidden && is_hidden_symbol (sym))))
1345             {
1346               sym->flags &= ~ (BSF_GLOBAL | BSF_WEAK);
1347               sym->flags |= BSF_LOCAL;
1348             }
1349
1350           if (!undefined
1351               && (flags & BSF_LOCAL)
1352               && is_specified_symbol (name, globalize_specific_htab))
1353             {
1354               sym->flags &= ~ BSF_LOCAL;
1355               sym->flags |= BSF_GLOBAL;
1356             }
1357
1358           to[dst_count++] = sym;
1359         }
1360     }
1361
1362   to[dst_count] = NULL;
1363
1364   return dst_count;
1365 }
1366
1367 /* Find the redefined name of symbol SOURCE.  */
1368
1369 static const char *
1370 lookup_sym_redefinition (const char *source)
1371 {
1372   struct redefine_node *list;
1373
1374   for (list = redefine_sym_list; list != NULL; list = list->next)
1375     if (strcmp (source, list->source) == 0)
1376       return list->target;
1377
1378   return source;
1379 }
1380
1381 /* Add a node to a symbol redefine list.  */
1382
1383 static void
1384 redefine_list_append (const char *cause, const char *source, const char *target)
1385 {
1386   struct redefine_node **p;
1387   struct redefine_node *list;
1388   struct redefine_node *new_node;
1389
1390   for (p = &redefine_sym_list; (list = *p) != NULL; p = &list->next)
1391     {
1392       if (strcmp (source, list->source) == 0)
1393         fatal (_("%s: Multiple redefinition of symbol \"%s\""),
1394                cause, source);
1395
1396       if (strcmp (target, list->target) == 0)
1397         fatal (_("%s: Symbol \"%s\" is target of more than one redefinition"),
1398                cause, target);
1399     }
1400
1401   new_node = (struct redefine_node *) xmalloc (sizeof (struct redefine_node));
1402
1403   new_node->source = strdup (source);
1404   new_node->target = strdup (target);
1405   new_node->next = NULL;
1406
1407   *p = new_node;
1408 }
1409
1410 /* Handle the --redefine-syms option.  Read lines containing "old new"
1411    from the file, and add them to the symbol redefine list.  */
1412
1413 static void
1414 add_redefine_syms_file (const char *filename)
1415 {
1416   FILE *file;
1417   char *buf;
1418   size_t bufsize;
1419   size_t len;
1420   size_t outsym_off;
1421   int c, lineno;
1422
1423   file = fopen (filename, "r");
1424   if (file == NULL)
1425     fatal (_("couldn't open symbol redefinition file %s (error: %s)"),
1426            filename, strerror (errno));
1427
1428   bufsize = 100;
1429   buf = (char *) xmalloc (bufsize + 1 /* For the terminating NUL.  */);
1430
1431   lineno = 1;
1432   c = getc (file);
1433   len = 0;
1434   outsym_off = 0;
1435   while (c != EOF)
1436     {
1437       /* Collect the input symbol name.  */
1438       while (! IS_WHITESPACE (c) && ! IS_LINE_TERMINATOR (c) && c != EOF)
1439         {
1440           if (c == '#')
1441             goto comment;
1442           buf[len++] = c;
1443           if (len >= bufsize)
1444             {
1445               bufsize *= 2;
1446               buf = (char *) xrealloc (buf, bufsize + 1);
1447             }
1448           c = getc (file);
1449         }
1450       buf[len++] = '\0';
1451       if (c == EOF)
1452         break;
1453
1454       /* Eat white space between the symbol names.  */
1455       while (IS_WHITESPACE (c))
1456         c = getc (file);
1457       if (c == '#' || IS_LINE_TERMINATOR (c))
1458         goto comment;
1459       if (c == EOF)
1460         break;
1461
1462       /* Collect the output symbol name.  */
1463       outsym_off = len;
1464       while (! IS_WHITESPACE (c) && ! IS_LINE_TERMINATOR (c) && c != EOF)
1465         {
1466           if (c == '#')
1467             goto comment;
1468           buf[len++] = c;
1469           if (len >= bufsize)
1470             {
1471               bufsize *= 2;
1472               buf = (char *) xrealloc (buf, bufsize + 1);
1473             }
1474           c = getc (file);
1475         }
1476       buf[len++] = '\0';
1477       if (c == EOF)
1478         break;
1479
1480       /* Eat white space at end of line.  */
1481       while (! IS_LINE_TERMINATOR(c) && c != EOF && IS_WHITESPACE (c))
1482         c = getc (file);
1483       if (c == '#')
1484         goto comment;
1485       /* Handle \r\n.  */
1486       if ((c == '\r' && (c = getc (file)) == '\n')
1487           || c == '\n' || c == EOF)
1488         {
1489  end_of_line:
1490           /* Append the redefinition to the list.  */
1491           if (buf[0] != '\0')
1492             redefine_list_append (filename, &buf[0], &buf[outsym_off]);
1493
1494           lineno++;
1495           len = 0;
1496           outsym_off = 0;
1497           if (c == EOF)
1498             break;
1499           c = getc (file);
1500           continue;
1501         }
1502       else
1503         fatal (_("%s:%d: garbage found at end of line"), filename, lineno);
1504  comment:
1505       if (len != 0 && (outsym_off == 0 || outsym_off == len))
1506         fatal (_("%s:%d: missing new symbol name"), filename, lineno);
1507       buf[len++] = '\0';
1508
1509       /* Eat the rest of the line and finish it.  */
1510       while (c != '\n' && c != EOF)
1511         c = getc (file);
1512       goto end_of_line;
1513     }
1514
1515   if (len != 0)
1516     fatal (_("%s:%d: premature end of file"), filename, lineno);
1517
1518   free (buf);
1519 }
1520
1521 /* Copy unkown object file IBFD onto OBFD.
1522    Returns TRUE upon success, FALSE otherwise.  */
1523
1524 static bfd_boolean
1525 copy_unknown_object (bfd *ibfd, bfd *obfd)
1526 {
1527   char *cbuf;
1528   int tocopy;
1529   long ncopied;
1530   long size;
1531   struct stat buf;
1532
1533   if (bfd_stat_arch_elt (ibfd, &buf) != 0)
1534     {
1535       bfd_nonfatal_message (NULL, ibfd, NULL, NULL);
1536       return FALSE;
1537     }
1538
1539   size = buf.st_size;
1540   if (size < 0)
1541     {
1542       non_fatal (_("stat returns negative size for `%s'"),
1543                  bfd_get_archive_filename (ibfd));
1544       return FALSE;
1545     }
1546
1547   if (bfd_seek (ibfd, (file_ptr) 0, SEEK_SET) != 0)
1548     {
1549       bfd_nonfatal (bfd_get_archive_filename (ibfd));
1550       return FALSE;
1551     }
1552
1553   if (verbose)
1554     printf (_("copy from `%s' [unknown] to `%s' [unknown]\n"),
1555             bfd_get_archive_filename (ibfd), bfd_get_filename (obfd));
1556
1557   cbuf = (char *) xmalloc (BUFSIZE);
1558   ncopied = 0;
1559   while (ncopied < size)
1560     {
1561       tocopy = size - ncopied;
1562       if (tocopy > BUFSIZE)
1563         tocopy = BUFSIZE;
1564
1565       if (bfd_bread (cbuf, (bfd_size_type) tocopy, ibfd)
1566           != (bfd_size_type) tocopy)
1567         {
1568           bfd_nonfatal_message (NULL, ibfd, NULL, NULL);
1569           free (cbuf);
1570           return FALSE;
1571         }
1572
1573       if (bfd_bwrite (cbuf, (bfd_size_type) tocopy, obfd)
1574           != (bfd_size_type) tocopy)
1575         {
1576           bfd_nonfatal_message (NULL, obfd, NULL, NULL);
1577           free (cbuf);
1578           return FALSE;
1579         }
1580
1581       ncopied += tocopy;
1582     }
1583
1584   /* We should at least to be able to read it back when copying an
1585      unknown object in an archive.  */
1586   chmod (bfd_get_filename (obfd), buf.st_mode | S_IRUSR);
1587   free (cbuf);
1588   return TRUE;
1589 }
1590
1591 /* Copy object file IBFD onto OBFD.
1592    Returns TRUE upon success, FALSE otherwise.  */
1593
1594 static bfd_boolean
1595 copy_object (bfd *ibfd, bfd *obfd, const bfd_arch_info_type *input_arch)
1596 {
1597   bfd_vma start;
1598   long symcount;
1599   asection **osections = NULL;
1600   asection *gnu_debuglink_section = NULL;
1601   bfd_size_type *gaps = NULL;
1602   bfd_size_type max_gap = 0;
1603   long symsize;
1604   void *dhandle;
1605   enum bfd_architecture iarch;
1606   unsigned int imach;
1607
1608   if (ibfd->xvec->byteorder != obfd->xvec->byteorder
1609       && ibfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN
1610       && obfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN)
1611     fatal (_("Unable to change endianness of input file(s)"));
1612
1613   if (!bfd_set_format (obfd, bfd_get_format (ibfd)))
1614     {
1615       bfd_nonfatal_message (NULL, obfd, NULL, NULL);
1616       return FALSE;
1617     }
1618
1619   if (ibfd->sections == NULL)
1620     {
1621       non_fatal (_("error: the input file '%s' has no sections"),
1622                  bfd_get_archive_filename (ibfd));
1623       return FALSE;
1624     }
1625
1626   if (verbose)
1627     printf (_("copy from `%s' [%s] to `%s' [%s]\n"),
1628             bfd_get_archive_filename (ibfd), bfd_get_target (ibfd),
1629             bfd_get_filename (obfd), bfd_get_target (obfd));
1630
1631   if (extract_symbol)
1632     start = 0;
1633   else
1634     {
1635       if (set_start_set)
1636         start = set_start;
1637       else
1638         start = bfd_get_start_address (ibfd);
1639       start += change_start;
1640     }
1641
1642   /* Neither the start address nor the flags
1643      need to be set for a core file.  */
1644   if (bfd_get_format (obfd) != bfd_core)
1645     {
1646       flagword flags;
1647
1648       flags = bfd_get_file_flags (ibfd);
1649       flags |= bfd_flags_to_set;
1650       flags &= ~bfd_flags_to_clear;
1651       flags &= bfd_applicable_file_flags (obfd);
1652
1653       if (strip_symbols == STRIP_ALL)
1654         flags &= ~HAS_RELOC;
1655
1656       if (!bfd_set_start_address (obfd, start)
1657           || !bfd_set_file_flags (obfd, flags))
1658         {
1659           bfd_nonfatal_message (NULL, ibfd, NULL, NULL);
1660           return FALSE;
1661         }
1662     }
1663
1664   /* Copy architecture of input file to output file.  */
1665   iarch = bfd_get_arch (ibfd);
1666   imach = bfd_get_mach (ibfd);
1667   if (input_arch)
1668     {
1669       if (bfd_get_arch_info (ibfd) == NULL
1670           || bfd_get_arch_info (ibfd)->arch == bfd_arch_unknown)
1671         {
1672           iarch = input_arch->arch;
1673           imach = input_arch->mach;
1674         }
1675       else
1676         non_fatal (_("Input file `%s' ignores binary architecture parameter."),
1677                    bfd_get_archive_filename (ibfd));
1678     }
1679   if (!bfd_set_arch_mach (obfd, iarch, imach)
1680       && (ibfd->target_defaulted
1681           || bfd_get_arch (ibfd) != bfd_get_arch (obfd)))
1682     {
1683       if (bfd_get_arch (ibfd) == bfd_arch_unknown)
1684         non_fatal (_("Unable to recognise the format of the input file `%s'"),
1685                    bfd_get_archive_filename (ibfd));
1686       else
1687         non_fatal (_("Output file cannot represent architecture `%s'"),
1688                    bfd_printable_arch_mach (bfd_get_arch (ibfd),
1689                                             bfd_get_mach (ibfd)));
1690       return FALSE;
1691     }
1692
1693   if (!bfd_set_format (obfd, bfd_get_format (ibfd)))
1694     {
1695       bfd_nonfatal_message (NULL, ibfd, NULL, NULL);
1696       return FALSE;
1697     }
1698
1699   if (bfd_get_flavour (obfd) == bfd_target_coff_flavour
1700       && bfd_pei_p (obfd))
1701     {
1702       /* Set up PE parameters.  */
1703       pe_data_type *pe = pe_data (obfd);
1704
1705       /* Copy PE parameters before changing them.  */
1706       if (ibfd->xvec->flavour == bfd_target_coff_flavour
1707           && bfd_pei_p (ibfd))
1708         pe->pe_opthdr = pe_data (ibfd)->pe_opthdr;
1709
1710       if (pe_file_alignment != (bfd_vma) -1)
1711         pe->pe_opthdr.FileAlignment = pe_file_alignment;
1712       else
1713         pe_file_alignment = PE_DEF_FILE_ALIGNMENT;
1714
1715       if (pe_heap_commit != (bfd_vma) -1)
1716         pe->pe_opthdr.SizeOfHeapCommit = pe_heap_commit;
1717
1718       if (pe_heap_reserve != (bfd_vma) -1)
1719         pe->pe_opthdr.SizeOfHeapCommit = pe_heap_reserve;
1720
1721       if (pe_image_base != (bfd_vma) -1)
1722         pe->pe_opthdr.ImageBase = pe_image_base;
1723
1724       if (pe_section_alignment != (bfd_vma) -1)
1725         pe->pe_opthdr.SectionAlignment = pe_section_alignment;
1726       else
1727         pe_section_alignment = PE_DEF_SECTION_ALIGNMENT;
1728
1729       if (pe_stack_commit != (bfd_vma) -1)
1730         pe->pe_opthdr.SizeOfStackCommit = pe_stack_commit;
1731
1732       if (pe_stack_reserve != (bfd_vma) -1)
1733         pe->pe_opthdr.SizeOfStackCommit = pe_stack_reserve;
1734
1735       if (pe_subsystem != -1)
1736         pe->pe_opthdr.Subsystem = pe_subsystem;
1737
1738       if (pe_major_subsystem_version != -1)
1739         pe->pe_opthdr.MajorSubsystemVersion = pe_major_subsystem_version;
1740
1741       if (pe_minor_subsystem_version != -1)
1742         pe->pe_opthdr.MinorSubsystemVersion = pe_minor_subsystem_version;
1743
1744       if (pe_file_alignment > pe_section_alignment)
1745         {
1746           char file_alignment[20], section_alignment[20];
1747
1748           sprintf_vma (file_alignment, pe_file_alignment);
1749           sprintf_vma (section_alignment, pe_section_alignment);
1750           non_fatal (_("warning: file alignment (0x%s) > section alignment (0x%s)"),
1751
1752                      file_alignment, section_alignment);
1753         }
1754     }
1755
1756   if (isympp)
1757     free (isympp);
1758
1759   if (osympp != isympp)
1760     free (osympp);
1761
1762   isympp = NULL;
1763   osympp = NULL;
1764
1765   symsize = bfd_get_symtab_upper_bound (ibfd);
1766   if (symsize < 0)
1767     {
1768       bfd_nonfatal_message (NULL, ibfd, NULL, NULL);
1769       return FALSE;
1770     }
1771
1772   osympp = isympp = (asymbol **) xmalloc (symsize);
1773   symcount = bfd_canonicalize_symtab (ibfd, isympp);
1774   if (symcount < 0)
1775     {
1776       bfd_nonfatal_message (NULL, ibfd, NULL, NULL);
1777       return FALSE;
1778     }
1779
1780   /* BFD mandates that all output sections be created and sizes set before
1781      any output is done.  Thus, we traverse all sections multiple times.  */
1782   bfd_map_over_sections (ibfd, setup_section, obfd);
1783
1784   if (!extract_symbol)
1785     setup_bfd_headers (ibfd, obfd);
1786
1787   if (add_sections != NULL)
1788     {
1789       struct section_add *padd;
1790       struct section_list *pset;
1791
1792       for (padd = add_sections; padd != NULL; padd = padd->next)
1793         {
1794           flagword flags;
1795
1796           pset = find_section_list (padd->name, FALSE,
1797                                     SECTION_CONTEXT_SET_FLAGS);
1798           if (pset != NULL)
1799             flags = pset->flags | SEC_HAS_CONTENTS;
1800           else
1801             flags = SEC_HAS_CONTENTS | SEC_READONLY | SEC_DATA;
1802
1803           /* bfd_make_section_with_flags() does not return very helpful
1804              error codes, so check for the most likely user error first.  */
1805           if (bfd_get_section_by_name (obfd, padd->name))
1806             {
1807               bfd_nonfatal_message (NULL, obfd, NULL,
1808                                  _("can't add section '%s'"), padd->name);
1809               return FALSE;
1810             }
1811           else
1812             {
1813               /* We use LINKER_CREATED here so that the backend hooks
1814                  will create any special section type information,
1815                  instead of presuming we know what we're doing merely
1816                  because we set the flags.  */
1817               padd->section = bfd_make_section_with_flags
1818                 (obfd, padd->name, flags | SEC_LINKER_CREATED);
1819               if (padd->section == NULL)
1820                 {
1821                   bfd_nonfatal_message (NULL, obfd, NULL,
1822                                         _("can't create section `%s'"),
1823                                         padd->name);
1824                   return FALSE;
1825                 }
1826             }
1827
1828           if (! bfd_set_section_size (obfd, padd->section, padd->size))
1829             {
1830               bfd_nonfatal_message (NULL, obfd, padd->section, NULL);
1831               return FALSE;
1832             }
1833
1834           pset = find_section_list (padd->name, FALSE,
1835                                     SECTION_CONTEXT_SET_VMA | SECTION_CONTEXT_ALTER_VMA);
1836           if (pset != NULL
1837               && ! bfd_set_section_vma (obfd, padd->section, pset->vma_val))
1838             {
1839               bfd_nonfatal_message (NULL, obfd, padd->section, NULL);
1840               return FALSE;
1841             }
1842
1843           pset = find_section_list (padd->name, FALSE,
1844                                     SECTION_CONTEXT_SET_LMA | SECTION_CONTEXT_ALTER_LMA);
1845           if (pset != NULL)
1846             {
1847               padd->section->lma = pset->lma_val;
1848
1849               if (! bfd_set_section_alignment
1850                   (obfd, padd->section,
1851                    bfd_section_alignment (obfd, padd->section)))
1852                 {
1853                   bfd_nonfatal_message (NULL, obfd, padd->section, NULL);
1854                   return FALSE;
1855                 }
1856             }
1857         }
1858     }
1859
1860   if (dump_sections != NULL)
1861     {
1862       struct section_add * pdump;
1863
1864       for (pdump = dump_sections; pdump != NULL; pdump = pdump->next)
1865         {
1866           asection * sec;
1867
1868           sec = bfd_get_section_by_name (ibfd, pdump->name);
1869           if (sec == NULL)
1870             {
1871               bfd_nonfatal_message (NULL, ibfd, NULL,
1872                                     _("can't dump section '%s' - it does not exist"),
1873                                     pdump->name);
1874               continue;
1875             }
1876
1877           if ((bfd_get_section_flags (ibfd, sec) & SEC_HAS_CONTENTS) == 0)
1878             {
1879               bfd_nonfatal_message (NULL, ibfd, sec,
1880                                     _("can't dump section - it has no contents"));
1881               continue;
1882             }
1883           
1884           bfd_size_type size = bfd_get_section_size (sec);
1885           if (size == 0)
1886             {
1887               bfd_nonfatal_message (NULL, ibfd, sec,
1888                                     _("can't dump section - it is empty"));
1889               continue;
1890             }
1891
1892           FILE * f;
1893           f = fopen (pdump->filename, FOPEN_WB);
1894           if (f == NULL)
1895             {
1896               bfd_nonfatal_message (pdump->filename, NULL, NULL,
1897                                     _("could not open section dump file"));
1898               continue;
1899             }
1900
1901           bfd_byte * contents = xmalloc (size);
1902           if (bfd_get_section_contents (ibfd, sec, contents, 0, size))
1903             {
1904               if (fwrite (contents, 1, size, f) != size)
1905                 fatal (_("error writing section contents to %s (error: %s)"),
1906                        pdump->filename,
1907                        strerror (errno));
1908             }
1909           else
1910             bfd_nonfatal_message (NULL, ibfd, sec,
1911                                   _("could not retrieve section contents"));
1912
1913           fclose (f);
1914           free (contents);
1915         }
1916     }
1917   
1918   if (gnu_debuglink_filename != NULL)
1919     {
1920       /* PR 15125: Give a helpful warning message if
1921          the debuglink section already exists, and
1922          allow the rest of the copy to complete.  */
1923       if (bfd_get_section_by_name (obfd, ".gnu_debuglink"))
1924         {
1925           non_fatal (_("%s: debuglink section already exists"),
1926                      bfd_get_filename (obfd));
1927           gnu_debuglink_filename = NULL;
1928         }
1929       else
1930         {
1931           gnu_debuglink_section = bfd_create_gnu_debuglink_section
1932             (obfd, gnu_debuglink_filename);
1933
1934           if (gnu_debuglink_section == NULL)
1935             {
1936               bfd_nonfatal_message (NULL, obfd, NULL,
1937                                     _("cannot create debug link section `%s'"),
1938                                     gnu_debuglink_filename);
1939               return FALSE;
1940             }
1941
1942           /* Special processing for PE format files.  We
1943              have no way to distinguish PE from COFF here.  */
1944           if (bfd_get_flavour (obfd) == bfd_target_coff_flavour)
1945             {
1946               bfd_vma debuglink_vma;
1947               asection * highest_section;
1948               asection * sec;
1949
1950               /* The PE spec requires that all sections be adjacent and sorted
1951                  in ascending order of VMA.  It also specifies that debug
1952                  sections should be last.  This is despite the fact that debug
1953                  sections are not loaded into memory and so in theory have no
1954                  use for a VMA.
1955
1956                  This means that the debuglink section must be given a non-zero
1957                  VMA which makes it contiguous with other debug sections.  So
1958                  walk the current section list, find the section with the
1959                  highest VMA and start the debuglink section after that one.  */
1960               for (sec = obfd->sections, highest_section = NULL;
1961                    sec != NULL;
1962                    sec = sec->next)
1963                 if (sec->vma > 0
1964                     && (highest_section == NULL
1965                         || sec->vma > highest_section->vma))
1966                   highest_section = sec;
1967
1968               if (highest_section)
1969                 debuglink_vma = BFD_ALIGN (highest_section->vma
1970                                            + highest_section->size,
1971                                            /* FIXME: We ought to be using
1972                                               COFF_PAGE_SIZE here or maybe
1973                                               bfd_get_section_alignment() (if it
1974                                               was set) but since this is for PE
1975                                               and we know the required alignment
1976                                               it is easier just to hard code it.  */
1977                                            0x1000);
1978               else
1979                 /* Umm, not sure what to do in this case.  */
1980                 debuglink_vma = 0x1000;
1981
1982               bfd_set_section_vma (obfd, gnu_debuglink_section, debuglink_vma);
1983             }
1984         }
1985     }
1986
1987   if (bfd_count_sections (obfd) != 0
1988       && (gap_fill_set || pad_to_set))
1989     {
1990       asection **set;
1991       unsigned int c, i;
1992
1993       /* We must fill in gaps between the sections and/or we must pad
1994          the last section to a specified address.  We do this by
1995          grabbing a list of the sections, sorting them by VMA, and
1996          increasing the section sizes as required to fill the gaps.
1997          We write out the gap contents below.  */
1998
1999       c = bfd_count_sections (obfd);
2000       osections = (asection **) xmalloc (c * sizeof (asection *));
2001       set = osections;
2002       bfd_map_over_sections (obfd, get_sections, &set);
2003
2004       qsort (osections, c, sizeof (asection *), compare_section_lma);
2005
2006       gaps = (bfd_size_type *) xmalloc (c * sizeof (bfd_size_type));
2007       memset (gaps, 0, c * sizeof (bfd_size_type));
2008
2009       if (gap_fill_set)
2010         {
2011           for (i = 0; i < c - 1; i++)
2012             {
2013               flagword flags;
2014               bfd_size_type size;
2015               bfd_vma gap_start, gap_stop;
2016
2017               flags = bfd_get_section_flags (obfd, osections[i]);
2018               if ((flags & SEC_HAS_CONTENTS) == 0
2019                   || (flags & SEC_LOAD) == 0)
2020                 continue;
2021
2022               size = bfd_section_size (obfd, osections[i]);
2023               gap_start = bfd_section_lma (obfd, osections[i]) + size;
2024               gap_stop = bfd_section_lma (obfd, osections[i + 1]);
2025               if (gap_start < gap_stop)
2026                 {
2027                   if (! bfd_set_section_size (obfd, osections[i],
2028                                               size + (gap_stop - gap_start)))
2029                     {
2030                       bfd_nonfatal_message (NULL, obfd, osections[i],
2031                                             _("Can't fill gap after section"));
2032                       status = 1;
2033                       break;
2034                     }
2035                   gaps[i] = gap_stop - gap_start;
2036                   if (max_gap < gap_stop - gap_start)
2037                     max_gap = gap_stop - gap_start;
2038                 }
2039             }
2040         }
2041
2042       if (pad_to_set)
2043         {
2044           bfd_vma lma;
2045           bfd_size_type size;
2046
2047           lma = bfd_section_lma (obfd, osections[c - 1]);
2048           size = bfd_section_size (obfd, osections[c - 1]);
2049           if (lma + size < pad_to)
2050             {
2051               if (! bfd_set_section_size (obfd, osections[c - 1],
2052                                           pad_to - lma))
2053                 {
2054                   bfd_nonfatal_message (NULL, obfd, osections[c - 1],
2055                                         _("can't add padding"));
2056                   status = 1;
2057                 }
2058               else
2059                 {
2060                   gaps[c - 1] = pad_to - (lma + size);
2061                   if (max_gap < pad_to - (lma + size))
2062                     max_gap = pad_to - (lma + size);
2063                 }
2064             }
2065         }
2066     }
2067
2068   /* Symbol filtering must happen after the output sections
2069      have been created, but before their contents are set.  */
2070   dhandle = NULL;
2071   if (convert_debugging)
2072     dhandle = read_debugging_info (ibfd, isympp, symcount, FALSE);
2073
2074   if (strip_symbols == STRIP_DEBUG
2075       || strip_symbols == STRIP_ALL
2076       || strip_symbols == STRIP_UNNEEDED
2077       || strip_symbols == STRIP_NONDEBUG
2078       || strip_symbols == STRIP_DWO
2079       || strip_symbols == STRIP_NONDWO
2080       || discard_locals != LOCALS_UNDEF
2081       || localize_hidden
2082       || htab_elements (strip_specific_htab) != 0
2083       || htab_elements (keep_specific_htab) != 0
2084       || htab_elements (localize_specific_htab) != 0
2085       || htab_elements (globalize_specific_htab) != 0
2086       || htab_elements (keepglobal_specific_htab) != 0
2087       || htab_elements (weaken_specific_htab) != 0
2088       || prefix_symbols_string
2089       || sections_removed
2090       || sections_copied
2091       || convert_debugging
2092       || change_leading_char
2093       || remove_leading_char
2094       || redefine_sym_list
2095       || weaken)
2096     {
2097       /* Mark symbols used in output relocations so that they
2098          are kept, even if they are local labels or static symbols.
2099
2100          Note we iterate over the input sections examining their
2101          relocations since the relocations for the output sections
2102          haven't been set yet.  mark_symbols_used_in_relocations will
2103          ignore input sections which have no corresponding output
2104          section.  */
2105       if (strip_symbols != STRIP_ALL)
2106         bfd_map_over_sections (ibfd,
2107                                mark_symbols_used_in_relocations,
2108                                isympp);
2109       osympp = (asymbol **) xmalloc ((symcount + 1) * sizeof (asymbol *));
2110       symcount = filter_symbols (ibfd, obfd, osympp, isympp, symcount);
2111     }
2112
2113   if (convert_debugging && dhandle != NULL)
2114     {
2115       if (! write_debugging_info (obfd, dhandle, &symcount, &osympp))
2116         {
2117           status = 1;
2118           return FALSE;
2119         }
2120     }
2121
2122   bfd_set_symtab (obfd, osympp, symcount);
2123
2124   /* This has to happen before section positions are set.  */
2125   bfd_map_over_sections (ibfd, copy_relocations_in_section, obfd);
2126
2127   /* This has to happen after the symbol table has been set.  */
2128   bfd_map_over_sections (ibfd, copy_section, obfd);
2129
2130   if (add_sections != NULL)
2131     {
2132       struct section_add *padd;
2133
2134       for (padd = add_sections; padd != NULL; padd = padd->next)
2135         {
2136           if (! bfd_set_section_contents (obfd, padd->section, padd->contents,
2137                                           0, padd->size))
2138             {
2139               bfd_nonfatal_message (NULL, obfd, padd->section, NULL);
2140               return FALSE;
2141             }
2142         }
2143     }
2144
2145   if (gnu_debuglink_filename != NULL)
2146     {
2147       if (! bfd_fill_in_gnu_debuglink_section
2148           (obfd, gnu_debuglink_section, gnu_debuglink_filename))
2149         {
2150           bfd_nonfatal_message (NULL, obfd, NULL,
2151                                 _("cannot fill debug link section `%s'"),
2152                                 gnu_debuglink_filename);
2153           return FALSE;
2154         }
2155     }
2156
2157   if (gap_fill_set || pad_to_set)
2158     {
2159       bfd_byte *buf;
2160       int c, i;
2161
2162       /* Fill in the gaps.  */
2163       if (max_gap > 8192)
2164         max_gap = 8192;
2165       buf = (bfd_byte *) xmalloc (max_gap);
2166       memset (buf, gap_fill, max_gap);
2167
2168       c = bfd_count_sections (obfd);
2169       for (i = 0; i < c; i++)
2170         {
2171           if (gaps[i] != 0)
2172             {
2173               bfd_size_type left;
2174               file_ptr off;
2175
2176               left = gaps[i];
2177               off = bfd_section_size (obfd, osections[i]) - left;
2178
2179               while (left > 0)
2180                 {
2181                   bfd_size_type now;
2182
2183                   if (left > 8192)
2184                     now = 8192;
2185                   else
2186                     now = left;
2187
2188                   if (! bfd_set_section_contents (obfd, osections[i], buf,
2189                                                   off, now))
2190                     {
2191                       bfd_nonfatal_message (NULL, obfd, osections[i], NULL);
2192                       return FALSE;
2193                     }
2194
2195                   left -= now;
2196                   off += now;
2197                 }
2198             }
2199         }
2200     }
2201
2202   /* Do not copy backend data if --extract-symbol is passed; anything
2203      that needs to look at the section contents will fail.  */
2204   if (extract_symbol)
2205     return TRUE;
2206
2207   /* Allow the BFD backend to copy any private data it understands
2208      from the input BFD to the output BFD.  This is done last to
2209      permit the routine to look at the filtered symbol table, which is
2210      important for the ECOFF code at least.  */
2211   if (! bfd_copy_private_bfd_data (ibfd, obfd))
2212     {
2213       bfd_nonfatal_message (NULL, obfd, NULL,
2214                             _("error copying private BFD data"));
2215       return FALSE;
2216     }
2217
2218   /* Switch to the alternate machine code.  We have to do this at the
2219      very end, because we only initialize the header when we create
2220      the first section.  */
2221   if (use_alt_mach_code != 0)
2222     {
2223       if (! bfd_alt_mach_code (obfd, use_alt_mach_code))
2224         {
2225           non_fatal (_("this target does not support %lu alternative machine codes"),
2226                      use_alt_mach_code);
2227           if (bfd_get_flavour (obfd) == bfd_target_elf_flavour)
2228             {
2229               non_fatal (_("treating that number as an absolute e_machine value instead"));
2230               elf_elfheader (obfd)->e_machine = use_alt_mach_code;
2231             }
2232           else
2233             non_fatal (_("ignoring the alternative value"));
2234         }
2235     }
2236
2237   return TRUE;
2238 }
2239
2240 /* Read each archive element in turn from IBFD, copy the
2241    contents to temp file, and keep the temp file handle.
2242    If 'force_output_target' is TRUE then make sure that
2243    all elements in the new archive are of the type
2244    'output_target'.  */
2245
2246 static void
2247 copy_archive (bfd *ibfd, bfd *obfd, const char *output_target,
2248               bfd_boolean force_output_target,
2249               const bfd_arch_info_type *input_arch)
2250 {
2251   struct name_list
2252     {
2253       struct name_list *next;
2254       const char *name;
2255       bfd *obfd;
2256     } *list, *l;
2257   bfd **ptr = &obfd->archive_head;
2258   bfd *this_element;
2259   char *dir;
2260   const char *filename;
2261
2262   /* Make a temp directory to hold the contents.  */
2263   dir = make_tempdir (bfd_get_filename (obfd));
2264   if (dir == NULL)
2265       fatal (_("cannot create tempdir for archive copying (error: %s)"),
2266            strerror (errno));
2267
2268   if (strip_symbols == STRIP_ALL)
2269     obfd->has_armap = FALSE;
2270   else
2271     obfd->has_armap = ibfd->has_armap;
2272   obfd->is_thin_archive = ibfd->is_thin_archive;
2273
2274   if (deterministic)
2275     obfd->flags |= BFD_DETERMINISTIC_OUTPUT;
2276
2277   list = NULL;
2278
2279   this_element = bfd_openr_next_archived_file (ibfd, NULL);
2280
2281   if (!bfd_set_format (obfd, bfd_get_format (ibfd)))
2282     {
2283       status = 1;
2284       bfd_nonfatal_message (NULL, obfd, NULL, NULL);
2285       return;
2286     }
2287
2288   while (!status && this_element != NULL)
2289     {
2290       char *output_name;
2291       bfd *output_bfd;
2292       bfd *last_element;
2293       struct stat buf;
2294       int stat_status = 0;
2295       bfd_boolean del = TRUE;
2296       bfd_boolean ok_object;
2297
2298       /* PR binutils/17533: Do not allow directory traversal
2299          outside of the current directory tree by archive members.  */
2300       if (! is_valid_archive_path (bfd_get_filename (this_element)))
2301         {
2302           non_fatal (_("illegal pathname found in archive member: %s"),
2303                      bfd_get_filename (this_element));
2304           status = 1;
2305           goto cleanup_and_exit;
2306         }
2307
2308       /* Create an output file for this member.  */
2309       output_name = concat (dir, "/",
2310                             bfd_get_filename (this_element), (char *) 0);
2311
2312       /* If the file already exists, make another temp dir.  */
2313       if (stat (output_name, &buf) >= 0)
2314         {
2315           output_name = make_tempdir (output_name);
2316           if (output_name == NULL)
2317             {
2318               non_fatal (_("cannot create tempdir for archive copying (error: %s)"),
2319                          strerror (errno));
2320               status = 1;
2321               goto cleanup_and_exit;
2322             }
2323
2324           l = (struct name_list *) xmalloc (sizeof (struct name_list));
2325           l->name = output_name;
2326           l->next = list;
2327           l->obfd = NULL;
2328           list = l;
2329           output_name = concat (output_name, "/",
2330                                 bfd_get_filename (this_element), (char *) 0);
2331         }
2332
2333       if (preserve_dates)
2334         {
2335           stat_status = bfd_stat_arch_elt (this_element, &buf);
2336
2337           if (stat_status != 0)
2338             non_fatal (_("internal stat error on %s"),
2339                        bfd_get_filename (this_element));
2340         }
2341
2342       l = (struct name_list *) xmalloc (sizeof (struct name_list));
2343       l->name = output_name;
2344       l->next = list;
2345       l->obfd = NULL;
2346       list = l;
2347
2348       ok_object = bfd_check_format (this_element, bfd_object);
2349       if (!ok_object)
2350         bfd_nonfatal_message (NULL, this_element, NULL,
2351                               _("Unable to recognise the format of file"));
2352
2353       /* PR binutils/3110: Cope with archives
2354          containing multiple target types.  */
2355       if (force_output_target || !ok_object)
2356         output_bfd = bfd_openw (output_name, output_target);
2357       else
2358         output_bfd = bfd_openw (output_name, bfd_get_target (this_element));
2359
2360       if (output_bfd == NULL)
2361         {
2362           bfd_nonfatal_message (output_name, NULL, NULL, NULL);
2363           status = 1;
2364           goto cleanup_and_exit;
2365         }
2366
2367       if (ok_object)
2368         {
2369           del = !copy_object (this_element, output_bfd, input_arch);
2370
2371           if (del && bfd_get_arch (this_element) == bfd_arch_unknown)
2372             /* Try again as an unknown object file.  */
2373             ok_object = FALSE;
2374           else if (!bfd_close (output_bfd))
2375             {
2376               bfd_nonfatal_message (output_name, NULL, NULL, NULL);
2377               /* Error in new object file. Don't change archive.  */
2378               status = 1;
2379             }
2380         }
2381
2382       if (!ok_object)
2383         {
2384           del = !copy_unknown_object (this_element, output_bfd);
2385           if (!bfd_close_all_done (output_bfd))
2386             {
2387               bfd_nonfatal_message (output_name, NULL, NULL, NULL);
2388               /* Error in new object file. Don't change archive.  */
2389               status = 1;
2390             }
2391         }
2392
2393       if (del)
2394         {
2395           unlink (output_name);
2396           status = 1;
2397         }
2398       else
2399         {
2400           if (preserve_dates && stat_status == 0)
2401             set_times (output_name, &buf);
2402
2403           /* Open the newly output file and attach to our list.  */
2404           output_bfd = bfd_openr (output_name, output_target);
2405
2406           l->obfd = output_bfd;
2407
2408           *ptr = output_bfd;
2409           ptr = &output_bfd->archive_next;
2410
2411           last_element = this_element;
2412
2413           this_element = bfd_openr_next_archived_file (ibfd, last_element);
2414
2415           bfd_close (last_element);
2416         }
2417     }
2418   *ptr = NULL;
2419
2420   filename = bfd_get_filename (obfd);
2421   if (!bfd_close (obfd))
2422     {
2423       status = 1;
2424       bfd_nonfatal_message (filename, NULL, NULL, NULL);
2425     }
2426
2427   filename = bfd_get_filename (ibfd);
2428   if (!bfd_close (ibfd))
2429     {
2430       status = 1;
2431       bfd_nonfatal_message (filename, NULL, NULL, NULL);
2432     }
2433
2434  cleanup_and_exit:
2435   /* Delete all the files that we opened.  */
2436   for (l = list; l != NULL; l = l->next)
2437     {
2438       if (l->obfd == NULL)
2439         rmdir (l->name);
2440       else
2441         {
2442           bfd_close (l->obfd);
2443           unlink (l->name);
2444         }
2445     }
2446   rmdir (dir);
2447 }
2448
2449 static void
2450 set_long_section_mode (bfd *output_bfd, bfd *input_bfd, enum long_section_name_handling style)
2451 {
2452   /* This is only relevant to Coff targets.  */
2453   if (bfd_get_flavour (output_bfd) == bfd_target_coff_flavour)
2454     {
2455       if (style == KEEP
2456           && bfd_get_flavour (input_bfd) == bfd_target_coff_flavour)
2457         style = bfd_coff_long_section_names (input_bfd) ? ENABLE : DISABLE;
2458       bfd_coff_set_long_section_names (output_bfd, style != DISABLE);
2459     }
2460 }
2461
2462 /* The top-level control.  */
2463
2464 static void
2465 copy_file (const char *input_filename, const char *output_filename,
2466            const char *input_target,   const char *output_target,
2467            const bfd_arch_info_type *input_arch)
2468 {
2469   bfd *ibfd;
2470   char **obj_matching;
2471   char **core_matching;
2472   off_t size = get_file_size (input_filename);
2473
2474   if (size < 1)
2475     {
2476       if (size == 0)
2477         non_fatal (_("error: the input file '%s' is empty"),
2478                    input_filename);
2479       status = 1;
2480       return;
2481     }
2482
2483   /* To allow us to do "strip *" without dying on the first
2484      non-object file, failures are nonfatal.  */
2485   ibfd = bfd_openr (input_filename, input_target);
2486   if (ibfd == NULL)
2487     {
2488       bfd_nonfatal_message (input_filename, NULL, NULL, NULL);
2489       status = 1;
2490       return;
2491     }
2492
2493   switch (do_debug_sections)
2494     {
2495     case compress:
2496       ibfd->flags |= BFD_COMPRESS;
2497       break;
2498     case decompress:
2499       ibfd->flags |= BFD_DECOMPRESS;
2500       break;
2501     default:
2502       break;
2503     }
2504
2505   if (bfd_check_format (ibfd, bfd_archive))
2506     {
2507       bfd_boolean force_output_target;
2508       bfd *obfd;
2509
2510       /* bfd_get_target does not return the correct value until
2511          bfd_check_format succeeds.  */
2512       if (output_target == NULL)
2513         {
2514           output_target = bfd_get_target (ibfd);
2515           force_output_target = FALSE;
2516         }
2517       else
2518         force_output_target = TRUE;
2519
2520       obfd = bfd_openw (output_filename, output_target);
2521       if (obfd == NULL)
2522         {
2523           bfd_nonfatal_message (output_filename, NULL, NULL, NULL);
2524           status = 1;
2525           return;
2526         }
2527       /* This is a no-op on non-Coff targets.  */
2528       set_long_section_mode (obfd, ibfd, long_section_names);
2529
2530       copy_archive (ibfd, obfd, output_target, force_output_target, input_arch);
2531     }
2532   else if (bfd_check_format_matches (ibfd, bfd_object, &obj_matching))
2533     {
2534       bfd *obfd;
2535     do_copy:
2536
2537       /* bfd_get_target does not return the correct value until
2538          bfd_check_format succeeds.  */
2539       if (output_target == NULL)
2540         output_target = bfd_get_target (ibfd);
2541
2542       obfd = bfd_openw (output_filename, output_target);
2543       if (obfd == NULL)
2544         {
2545           bfd_nonfatal_message (output_filename, NULL, NULL, NULL);
2546           status = 1;
2547           return;
2548         }
2549       /* This is a no-op on non-Coff targets.  */
2550       set_long_section_mode (obfd, ibfd, long_section_names);
2551
2552       if (! copy_object (ibfd, obfd, input_arch))
2553         status = 1;
2554
2555       if (!bfd_close (obfd))
2556         {
2557           status = 1;
2558           bfd_nonfatal_message (output_filename, NULL, NULL, NULL);
2559           return;
2560         }
2561
2562       if (!bfd_close (ibfd))
2563         {
2564           status = 1;
2565           bfd_nonfatal_message (input_filename, NULL, NULL, NULL);
2566           return;
2567         }
2568     }
2569   else
2570     {
2571       bfd_error_type obj_error = bfd_get_error ();
2572       bfd_error_type core_error;
2573
2574       if (bfd_check_format_matches (ibfd, bfd_core, &core_matching))
2575         {
2576           /* This probably can't happen..  */
2577           if (obj_error == bfd_error_file_ambiguously_recognized)
2578             free (obj_matching);
2579           goto do_copy;
2580         }
2581
2582       core_error = bfd_get_error ();
2583       /* Report the object error in preference to the core error.  */
2584       if (obj_error != core_error)
2585         bfd_set_error (obj_error);
2586
2587       bfd_nonfatal_message (input_filename, NULL, NULL, NULL);
2588
2589       if (obj_error == bfd_error_file_ambiguously_recognized)
2590         {
2591           list_matching_formats (obj_matching);
2592           free (obj_matching);
2593         }
2594       if (core_error == bfd_error_file_ambiguously_recognized)
2595         {
2596           list_matching_formats (core_matching);
2597           free (core_matching);
2598         }
2599
2600       status = 1;
2601     }
2602 }
2603
2604 /* Add a name to the section renaming list.  */
2605
2606 static void
2607 add_section_rename (const char * old_name, const char * new_name,
2608                     flagword flags)
2609 {
2610   section_rename * srename;
2611
2612   /* Check for conflicts first.  */
2613   for (srename = section_rename_list; srename != NULL; srename = srename->next)
2614     if (strcmp (srename->old_name, old_name) == 0)
2615       {
2616         /* Silently ignore duplicate definitions.  */
2617         if (strcmp (srename->new_name, new_name) == 0
2618             && srename->flags == flags)
2619           return;
2620
2621         fatal (_("Multiple renames of section %s"), old_name);
2622       }
2623
2624   srename = (section_rename *) xmalloc (sizeof (* srename));
2625
2626   srename->old_name = old_name;
2627   srename->new_name = new_name;
2628   srename->flags    = flags;
2629   srename->next     = section_rename_list;
2630
2631   section_rename_list = srename;
2632 }
2633
2634 /* Check the section rename list for a new name of the input section
2635    ISECTION.  Return the new name if one is found.
2636    Also set RETURNED_FLAGS to the flags to be used for this section.  */
2637
2638 static const char *
2639 find_section_rename (bfd * ibfd ATTRIBUTE_UNUSED, sec_ptr isection,
2640                      flagword * returned_flags)
2641 {
2642   const char * old_name = bfd_section_name (ibfd, isection);
2643   section_rename * srename;
2644
2645   /* Default to using the flags of the input section.  */
2646   * returned_flags = bfd_get_section_flags (ibfd, isection);
2647
2648   for (srename = section_rename_list; srename != NULL; srename = srename->next)
2649     if (strcmp (srename->old_name, old_name) == 0)
2650       {
2651         if (srename->flags != (flagword) -1)
2652           * returned_flags = srename->flags;
2653
2654         return srename->new_name;
2655       }
2656
2657   return old_name;
2658 }
2659
2660 /* Once each of the sections is copied, we may still need to do some
2661    finalization work for private section headers.  Do that here.  */
2662
2663 static void
2664 setup_bfd_headers (bfd *ibfd, bfd *obfd)
2665 {
2666   /* Allow the BFD backend to copy any private data it understands
2667      from the input section to the output section.  */
2668   if (! bfd_copy_private_header_data (ibfd, obfd))
2669     {
2670       status = 1;
2671       bfd_nonfatal_message (NULL, ibfd, NULL,
2672                             _("error in private header data"));
2673       return;
2674     }
2675
2676   /* All went well.  */
2677   return;
2678 }
2679
2680 /* Create a section in OBFD with the same
2681    name and attributes as ISECTION in IBFD.  */
2682
2683 static void
2684 setup_section (bfd *ibfd, sec_ptr isection, void *obfdarg)
2685 {
2686   bfd *obfd = (bfd *) obfdarg;
2687   struct section_list *p;
2688   sec_ptr osection;
2689   bfd_size_type size;
2690   bfd_vma vma;
2691   bfd_vma lma;
2692   flagword flags;
2693   const char *err;
2694   const char * name;
2695   char *prefix = NULL;
2696   bfd_boolean make_nobits;
2697
2698   if (is_strip_section (ibfd, isection))
2699     return;
2700
2701   /* Get the, possibly new, name of the output section.  */
2702   name = find_section_rename (ibfd, isection, & flags);
2703
2704   /* Prefix sections.  */
2705   if ((prefix_alloc_sections_string)
2706       && (bfd_get_section_flags (ibfd, isection) & SEC_ALLOC))
2707     prefix = prefix_alloc_sections_string;
2708   else if (prefix_sections_string)
2709     prefix = prefix_sections_string;
2710
2711   if (prefix)
2712     {
2713       char *n;
2714
2715       n = (char *) xmalloc (strlen (prefix) + strlen (name) + 1);
2716       strcpy (n, prefix);
2717       strcat (n, name);
2718       name = n;
2719     }
2720
2721   make_nobits = FALSE;
2722
2723   p = find_section_list (bfd_section_name (ibfd, isection), FALSE,
2724                          SECTION_CONTEXT_SET_FLAGS);
2725   if (p != NULL)
2726     flags = p->flags | (flags & (SEC_HAS_CONTENTS | SEC_RELOC));
2727   else if (strip_symbols == STRIP_NONDEBUG
2728            && (flags & (SEC_ALLOC | SEC_GROUP)) != 0
2729            && !is_nondebug_keep_contents_section (ibfd, isection))
2730     {
2731       flags &= ~(SEC_HAS_CONTENTS | SEC_LOAD | SEC_GROUP);
2732       if (obfd->xvec->flavour == bfd_target_elf_flavour)
2733         {
2734           make_nobits = TRUE;
2735
2736           /* Twiddle the input section flags so that it seems to
2737              elf.c:copy_private_bfd_data that section flags have not
2738              changed between input and output sections.  This hack
2739              prevents wholesale rewriting of the program headers.  */
2740           isection->flags &= ~(SEC_HAS_CONTENTS | SEC_LOAD | SEC_GROUP);
2741         }
2742     }
2743
2744   osection = bfd_make_section_anyway_with_flags (obfd, name, flags);
2745
2746   if (osection == NULL)
2747     {
2748       err = _("failed to create output section");
2749       goto loser;
2750     }
2751
2752   if (make_nobits)
2753     elf_section_type (osection) = SHT_NOBITS;
2754
2755   size = bfd_section_size (ibfd, isection);
2756   if (copy_byte >= 0)
2757     size = (size + interleave - 1) / interleave * copy_width;
2758   else if (extract_symbol)
2759     size = 0;
2760   if (! bfd_set_section_size (obfd, osection, size))
2761     {
2762       err = _("failed to set size");
2763       goto loser;
2764     }
2765
2766   vma = bfd_section_vma (ibfd, isection);
2767   p = find_section_list (bfd_section_name (ibfd, isection), FALSE,
2768                          SECTION_CONTEXT_ALTER_VMA | SECTION_CONTEXT_SET_VMA);
2769   if (p != NULL)
2770     {
2771       if (p->context & SECTION_CONTEXT_SET_VMA)
2772         vma = p->vma_val;
2773       else
2774         vma += p->vma_val;
2775     }
2776   else
2777     vma += change_section_address;
2778
2779   if (! bfd_set_section_vma (obfd, osection, vma))
2780     {
2781       err = _("failed to set vma");
2782       goto loser;
2783     }
2784
2785   lma = isection->lma;
2786   p = find_section_list (bfd_section_name (ibfd, isection), FALSE,
2787                          SECTION_CONTEXT_ALTER_LMA | SECTION_CONTEXT_SET_LMA);
2788   if (p != NULL)
2789     {
2790       if (p->context & SECTION_CONTEXT_ALTER_LMA)
2791         lma += p->lma_val;
2792       else
2793         lma = p->lma_val;
2794     }
2795   else
2796     lma += change_section_address;
2797
2798   osection->lma = lma;
2799
2800   /* FIXME: This is probably not enough.  If we change the LMA we
2801      may have to recompute the header for the file as well.  */
2802   if (!bfd_set_section_alignment (obfd,
2803                                   osection,
2804                                   bfd_section_alignment (ibfd, isection)))
2805     {
2806       err = _("failed to set alignment");
2807       goto loser;
2808     }
2809
2810   /* Copy merge entity size.  */
2811   osection->entsize = isection->entsize;
2812
2813   /* This used to be mangle_section; we do here to avoid using
2814      bfd_get_section_by_name since some formats allow multiple
2815      sections with the same name.  */
2816   isection->output_section = osection;
2817   isection->output_offset = 0;
2818
2819   /* Do not copy backend data if --extract-symbol is passed; anything
2820      that needs to look at the section contents will fail.  */
2821   if (extract_symbol)
2822     return;
2823
2824   if ((isection->flags & SEC_GROUP) != 0)
2825     {
2826       asymbol *gsym = group_signature (isection);
2827
2828       if (gsym != NULL)
2829         {
2830           gsym->flags |= BSF_KEEP;
2831           if (ibfd->xvec->flavour == bfd_target_elf_flavour)
2832             elf_group_id (isection) = gsym;
2833         }
2834     }
2835
2836   /* Allow the BFD backend to copy any private data it understands
2837      from the input section to the output section.  */
2838   if (!bfd_copy_private_section_data (ibfd, isection, obfd, osection))
2839     {
2840       err = _("failed to copy private data");
2841       goto loser;
2842     }
2843
2844   /* All went well.  */
2845   return;
2846
2847 loser:
2848   status = 1;
2849   bfd_nonfatal_message (NULL, obfd, osection, err);
2850 }
2851
2852 /* Return TRUE if input section ISECTION should be skipped.  */
2853
2854 static bfd_boolean
2855 skip_section (bfd *ibfd, sec_ptr isection)
2856 {
2857   sec_ptr osection;
2858   bfd_size_type size;
2859   flagword flags;
2860
2861   /* If we have already failed earlier on,
2862      do not keep on generating complaints now.  */
2863   if (status != 0)
2864     return TRUE;
2865
2866   if (extract_symbol)
2867     return TRUE;
2868
2869   if (is_strip_section (ibfd, isection))
2870     return TRUE;
2871
2872   flags = bfd_get_section_flags (ibfd, isection);
2873   if ((flags & SEC_GROUP) != 0)
2874     return TRUE;
2875
2876   osection = isection->output_section;
2877   size = bfd_get_section_size (isection);
2878
2879   if (size == 0 || osection == 0)
2880     return TRUE;
2881
2882   return FALSE;
2883 }
2884
2885 /* Copy relocations in input section ISECTION of IBFD to an output
2886    section with the same name in OBFDARG.  If stripping then don't
2887    copy any relocation info.  */
2888
2889 static void
2890 copy_relocations_in_section (bfd *ibfd, sec_ptr isection, void *obfdarg)
2891 {
2892   bfd *obfd = (bfd *) obfdarg;
2893   long relsize;
2894   arelent **relpp;
2895   long relcount;
2896   sec_ptr osection;
2897
2898   if (skip_section (ibfd, isection))
2899     return;
2900
2901   osection = isection->output_section;
2902
2903   /* Core files and DWO files do not need to be relocated.  */
2904   if (bfd_get_format (obfd) == bfd_core || strip_symbols == STRIP_NONDWO)
2905     relsize = 0;
2906   else
2907     {
2908       relsize = bfd_get_reloc_upper_bound (ibfd, isection);
2909
2910       if (relsize < 0)
2911         {
2912           /* Do not complain if the target does not support relocations.  */
2913           if (relsize == -1 && bfd_get_error () == bfd_error_invalid_operation)
2914             relsize = 0;
2915           else
2916             {
2917               status = 1;
2918               bfd_nonfatal_message (NULL, ibfd, isection, NULL);
2919               return;
2920             }
2921         }
2922     }
2923
2924   if (relsize == 0)
2925     {
2926       bfd_set_reloc (obfd, osection, NULL, 0);
2927       osection->flags &= ~SEC_RELOC;
2928     }
2929   else
2930     {
2931       relpp = (arelent **) xmalloc (relsize);
2932       relcount = bfd_canonicalize_reloc (ibfd, isection, relpp, isympp);
2933       if (relcount < 0)
2934         {
2935           status = 1;
2936           bfd_nonfatal_message (NULL, ibfd, isection,
2937                                 _("relocation count is negative"));
2938           return;
2939         }
2940
2941       if (strip_symbols == STRIP_ALL)
2942         {
2943           /* Remove relocations which are not in
2944              keep_strip_specific_list.  */
2945           arelent **temp_relpp;
2946           long temp_relcount = 0;
2947           long i;
2948
2949           temp_relpp = (arelent **) xmalloc (relsize);
2950           for (i = 0; i < relcount; i++)
2951             if (is_specified_symbol (bfd_asymbol_name (*relpp[i]->sym_ptr_ptr),
2952                                      keep_specific_htab))
2953               temp_relpp [temp_relcount++] = relpp [i];
2954           relcount = temp_relcount;
2955           free (relpp);
2956           relpp = temp_relpp;
2957         }
2958
2959       bfd_set_reloc (obfd, osection, relcount == 0 ? NULL : relpp, relcount);
2960       if (relcount == 0)
2961         {
2962           osection->flags &= ~SEC_RELOC;
2963           free (relpp);
2964         }
2965     }
2966 }
2967
2968 /* Copy the data of input section ISECTION of IBFD
2969    to an output section with the same name in OBFD.  */
2970
2971 static void
2972 copy_section (bfd *ibfd, sec_ptr isection, void *obfdarg)
2973 {
2974   bfd *obfd = (bfd *) obfdarg;
2975   struct section_list *p;
2976   sec_ptr osection;
2977   bfd_size_type size;
2978
2979   if (skip_section (ibfd, isection))
2980     return;
2981
2982   osection = isection->output_section;
2983   size = bfd_get_section_size (isection);
2984
2985   if (bfd_get_section_flags (ibfd, isection) & SEC_HAS_CONTENTS
2986       && bfd_get_section_flags (obfd, osection) & SEC_HAS_CONTENTS)
2987     {
2988       bfd_byte *memhunk = NULL;
2989
2990       if (!bfd_get_full_section_contents (ibfd, isection, &memhunk))
2991         {
2992           status = 1;
2993           bfd_nonfatal_message (NULL, ibfd, isection, NULL);
2994           return;
2995         }
2996
2997       if (reverse_bytes)
2998         {
2999           /* We don't handle leftover bytes (too many possible behaviors,
3000              and we don't know what the user wants).  The section length
3001              must be a multiple of the number of bytes to swap.  */
3002           if ((size % reverse_bytes) == 0)
3003             {
3004               unsigned long i, j;
3005               bfd_byte b;
3006
3007               for (i = 0; i < size; i += reverse_bytes)
3008                 for (j = 0; j < (unsigned long)(reverse_bytes / 2); j++)
3009                   {
3010                     bfd_byte *m = (bfd_byte *) memhunk;
3011
3012                     b = m[i + j];
3013                     m[i + j] = m[(i + reverse_bytes) - (j + 1)];
3014                     m[(i + reverse_bytes) - (j + 1)] = b;
3015                   }
3016             }
3017           else
3018             /* User must pad the section up in order to do this.  */
3019             fatal (_("cannot reverse bytes: length of section %s must be evenly divisible by %d"),
3020                    bfd_section_name (ibfd, isection), reverse_bytes);
3021         }
3022
3023       if (copy_byte >= 0)
3024         {
3025           /* Keep only every `copy_byte'th byte in MEMHUNK.  */
3026           char *from = (char *) memhunk + copy_byte;
3027           char *to = (char *) memhunk;
3028           char *end = (char *) memhunk + size;
3029           int i;
3030
3031           for (; from < end; from += interleave)
3032             for (i = 0; i < copy_width; i++)
3033               {
3034                 if (&from[i] >= end)
3035                   break;
3036                 *to++ = from[i];
3037               }
3038
3039           size = (size + interleave - 1 - copy_byte) / interleave * copy_width;
3040           osection->lma /= interleave;
3041         }
3042
3043       if (!bfd_set_section_contents (obfd, osection, memhunk, 0, size))
3044         {
3045           status = 1;
3046           bfd_nonfatal_message (NULL, obfd, osection, NULL);
3047           return;
3048         }
3049       free (memhunk);
3050     }
3051   else if ((p = find_section_list (bfd_get_section_name (ibfd, isection),
3052                                    FALSE, SECTION_CONTEXT_SET_FLAGS)) != NULL
3053            && (p->flags & SEC_HAS_CONTENTS) != 0)
3054     {
3055       void *memhunk = xmalloc (size);
3056
3057       /* We don't permit the user to turn off the SEC_HAS_CONTENTS
3058          flag--they can just remove the section entirely and add it
3059          back again.  However, we do permit them to turn on the
3060          SEC_HAS_CONTENTS flag, and take it to mean that the section
3061          contents should be zeroed out.  */
3062
3063       memset (memhunk, 0, size);
3064       if (! bfd_set_section_contents (obfd, osection, memhunk, 0, size))
3065         {
3066           status = 1;
3067           bfd_nonfatal_message (NULL, obfd, osection, NULL);
3068           return;
3069         }
3070       free (memhunk);
3071     }
3072 }
3073
3074 /* Get all the sections.  This is used when --gap-fill or --pad-to is
3075    used.  */
3076
3077 static void
3078 get_sections (bfd *obfd ATTRIBUTE_UNUSED, asection *osection, void *secppparg)
3079 {
3080   asection ***secppp = (asection ***) secppparg;
3081
3082   **secppp = osection;
3083   ++(*secppp);
3084 }
3085
3086 /* Sort sections by VMA.  This is called via qsort, and is used when
3087    --gap-fill or --pad-to is used.  We force non loadable or empty
3088    sections to the front, where they are easier to ignore.  */
3089
3090 static int
3091 compare_section_lma (const void *arg1, const void *arg2)
3092 {
3093   const asection *const *sec1 = (const asection * const *) arg1;
3094   const asection *const *sec2 = (const asection * const *) arg2;
3095   flagword flags1, flags2;
3096
3097   /* Sort non loadable sections to the front.  */
3098   flags1 = (*sec1)->flags;
3099   flags2 = (*sec2)->flags;
3100   if ((flags1 & SEC_HAS_CONTENTS) == 0
3101       || (flags1 & SEC_LOAD) == 0)
3102     {
3103       if ((flags2 & SEC_HAS_CONTENTS) != 0
3104           && (flags2 & SEC_LOAD) != 0)
3105         return -1;
3106     }
3107   else
3108     {
3109       if ((flags2 & SEC_HAS_CONTENTS) == 0
3110           || (flags2 & SEC_LOAD) == 0)
3111         return 1;
3112     }
3113
3114   /* Sort sections by LMA.  */
3115   if ((*sec1)->lma > (*sec2)->lma)
3116     return 1;
3117   else if ((*sec1)->lma < (*sec2)->lma)
3118     return -1;
3119
3120   /* Sort sections with the same LMA by size.  */
3121   if (bfd_get_section_size (*sec1) > bfd_get_section_size (*sec2))
3122     return 1;
3123   else if (bfd_get_section_size (*sec1) < bfd_get_section_size (*sec2))
3124     return -1;
3125
3126   return 0;
3127 }
3128
3129 /* Mark all the symbols which will be used in output relocations with
3130    the BSF_KEEP flag so that those symbols will not be stripped.
3131
3132    Ignore relocations which will not appear in the output file.  */
3133
3134 static void
3135 mark_symbols_used_in_relocations (bfd *ibfd, sec_ptr isection, void *symbolsarg)
3136 {
3137   asymbol **symbols = (asymbol **) symbolsarg;
3138   long relsize;
3139   arelent **relpp;
3140   long relcount, i;
3141
3142   /* Ignore an input section with no corresponding output section.  */
3143   if (isection->output_section == NULL)
3144     return;
3145
3146   relsize = bfd_get_reloc_upper_bound (ibfd, isection);
3147   if (relsize < 0)
3148     {
3149       /* Do not complain if the target does not support relocations.  */
3150       if (relsize == -1 && bfd_get_error () == bfd_error_invalid_operation)
3151         return;
3152       bfd_fatal (bfd_get_filename (ibfd));
3153     }
3154
3155   if (relsize == 0)
3156     return;
3157
3158   relpp = (arelent **) xmalloc (relsize);
3159   relcount = bfd_canonicalize_reloc (ibfd, isection, relpp, symbols);
3160   if (relcount < 0)
3161     bfd_fatal (bfd_get_filename (ibfd));
3162
3163   /* Examine each symbol used in a relocation.  If it's not one of the
3164      special bfd section symbols, then mark it with BSF_KEEP.  */
3165   for (i = 0; i < relcount; i++)
3166     {
3167       if (*relpp[i]->sym_ptr_ptr != bfd_com_section_ptr->symbol
3168           && *relpp[i]->sym_ptr_ptr != bfd_abs_section_ptr->symbol
3169           && *relpp[i]->sym_ptr_ptr != bfd_und_section_ptr->symbol)
3170         (*relpp[i]->sym_ptr_ptr)->flags |= BSF_KEEP;
3171     }
3172
3173   if (relpp != NULL)
3174     free (relpp);
3175 }
3176
3177 /* Write out debugging information.  */
3178
3179 static bfd_boolean
3180 write_debugging_info (bfd *obfd, void *dhandle,
3181                       long *symcountp ATTRIBUTE_UNUSED,
3182                       asymbol ***symppp ATTRIBUTE_UNUSED)
3183 {
3184   if (bfd_get_flavour (obfd) == bfd_target_ieee_flavour)
3185     return write_ieee_debugging_info (obfd, dhandle);
3186
3187   if (bfd_get_flavour (obfd) == bfd_target_coff_flavour
3188       || bfd_get_flavour (obfd) == bfd_target_elf_flavour)
3189     {
3190       bfd_byte *syms, *strings;
3191       bfd_size_type symsize, stringsize;
3192       asection *stabsec, *stabstrsec;
3193       flagword flags;
3194
3195       if (! write_stabs_in_sections_debugging_info (obfd, dhandle, &syms,
3196                                                     &symsize, &strings,
3197                                                     &stringsize))
3198         return FALSE;
3199
3200       flags = SEC_HAS_CONTENTS | SEC_READONLY | SEC_DEBUGGING;
3201       stabsec = bfd_make_section_with_flags (obfd, ".stab", flags);
3202       stabstrsec = bfd_make_section_with_flags (obfd, ".stabstr", flags);
3203       if (stabsec == NULL
3204           || stabstrsec == NULL
3205           || ! bfd_set_section_size (obfd, stabsec, symsize)
3206           || ! bfd_set_section_size (obfd, stabstrsec, stringsize)
3207           || ! bfd_set_section_alignment (obfd, stabsec, 2)
3208           || ! bfd_set_section_alignment (obfd, stabstrsec, 0))
3209         {
3210           bfd_nonfatal_message (NULL, obfd, NULL,
3211                                 _("can't create debugging section"));
3212           return FALSE;
3213         }
3214
3215       /* We can get away with setting the section contents now because
3216          the next thing the caller is going to do is copy over the
3217          real sections.  We may someday have to split the contents
3218          setting out of this function.  */
3219       if (! bfd_set_section_contents (obfd, stabsec, syms, 0, symsize)
3220           || ! bfd_set_section_contents (obfd, stabstrsec, strings, 0,
3221                                          stringsize))
3222         {
3223           bfd_nonfatal_message (NULL, obfd, NULL,
3224                                 _("can't set debugging section contents"));
3225           return FALSE;
3226         }
3227
3228       return TRUE;
3229     }
3230
3231   bfd_nonfatal_message (NULL, obfd, NULL,
3232                         _("don't know how to write debugging information for %s"),
3233              bfd_get_target (obfd));
3234   return FALSE;
3235 }
3236
3237 /* If neither -D nor -U was specified explicitly,
3238    then use the configured default.  */
3239 static void
3240 default_deterministic (void)
3241 {
3242   if (deterministic < 0)
3243     deterministic = DEFAULT_AR_DETERMINISTIC;
3244 }
3245
3246 static int
3247 strip_main (int argc, char *argv[])
3248 {
3249   char *input_target = NULL;
3250   char *output_target = NULL;
3251   bfd_boolean show_version = FALSE;
3252   bfd_boolean formats_info = FALSE;
3253   int c;
3254   int i;
3255   char *output_file = NULL;
3256
3257   while ((c = getopt_long (argc, argv, "I:O:F:K:N:R:o:sSpdgxXHhVvw",
3258                            strip_options, (int *) 0)) != EOF)
3259     {
3260       switch (c)
3261         {
3262         case 'I':
3263           input_target = optarg;
3264           break;
3265         case 'O':
3266           output_target = optarg;
3267           break;
3268         case 'F':
3269           input_target = output_target = optarg;
3270           break;
3271         case 'R':
3272           find_section_list (optarg, TRUE, SECTION_CONTEXT_REMOVE);
3273           sections_removed = TRUE;
3274           break;
3275         case 's':
3276           strip_symbols = STRIP_ALL;
3277           break;
3278         case 'S':
3279         case 'g':
3280         case 'd':       /* Historic BSD alias for -g.  Used by early NetBSD.  */
3281           strip_symbols = STRIP_DEBUG;
3282           break;
3283         case OPTION_STRIP_DWO:
3284           strip_symbols = STRIP_DWO;
3285           break;
3286         case OPTION_STRIP_UNNEEDED:
3287           strip_symbols = STRIP_UNNEEDED;
3288           break;
3289         case 'K':
3290           add_specific_symbol (optarg, keep_specific_htab);
3291           break;
3292         case 'N':
3293           add_specific_symbol (optarg, strip_specific_htab);
3294           break;
3295         case 'o':
3296           output_file = optarg;
3297           break;
3298         case 'p':
3299           preserve_dates = TRUE;
3300           break;
3301         case 'D':
3302           deterministic = TRUE;
3303           break;
3304         case 'U':
3305           deterministic = FALSE;
3306           break;
3307         case 'x':
3308           discard_locals = LOCALS_ALL;
3309           break;
3310         case 'X':
3311           discard_locals = LOCALS_START_L;
3312           break;
3313         case 'v':
3314           verbose = TRUE;
3315           break;
3316         case 'V':
3317           show_version = TRUE;
3318           break;
3319         case OPTION_FORMATS_INFO:
3320           formats_info = TRUE;
3321           break;
3322         case OPTION_ONLY_KEEP_DEBUG:
3323           strip_symbols = STRIP_NONDEBUG;
3324           break;
3325         case OPTION_KEEP_FILE_SYMBOLS:
3326           keep_file_symbols = 1;
3327           break;
3328         case 0:
3329           /* We've been given a long option.  */
3330           break;
3331         case 'w':
3332           wildcard = TRUE;
3333           break;
3334         case 'H':
3335         case 'h':
3336           strip_usage (stdout, 0);
3337         default:
3338           strip_usage (stderr, 1);
3339         }
3340     }
3341
3342   if (formats_info)
3343     {
3344       display_info ();
3345       return 0;
3346     }
3347
3348   if (show_version)
3349     print_version ("strip");
3350
3351   default_deterministic ();
3352
3353   /* Default is to strip all symbols.  */
3354   if (strip_symbols == STRIP_UNDEF
3355       && discard_locals == LOCALS_UNDEF
3356       && htab_elements (strip_specific_htab) == 0)
3357     strip_symbols = STRIP_ALL;
3358
3359   if (output_target == NULL)
3360     output_target = input_target;
3361
3362   i = optind;
3363   if (i == argc
3364       || (output_file != NULL && (i + 1) < argc))
3365     strip_usage (stderr, 1);
3366
3367   for (; i < argc; i++)
3368     {
3369       int hold_status = status;
3370       struct stat statbuf;
3371       char *tmpname;
3372
3373       if (get_file_size (argv[i]) < 1)
3374         {
3375           status = 1;
3376           continue;
3377         }
3378
3379       if (preserve_dates)
3380         /* No need to check the return value of stat().
3381            It has already been checked in get_file_size().  */
3382         stat (argv[i], &statbuf);
3383
3384       if (output_file == NULL
3385           || filename_cmp (argv[i], output_file) == 0)
3386         tmpname = make_tempname (argv[i]);
3387       else
3388         tmpname = output_file;
3389
3390       if (tmpname == NULL)
3391         {
3392           bfd_nonfatal_message (argv[i], NULL, NULL,
3393                                 _("could not create temporary file to hold stripped copy"));
3394           status = 1;
3395           continue;
3396         }
3397
3398       status = 0;
3399       copy_file (argv[i], tmpname, input_target, output_target, NULL);
3400       if (status == 0)
3401         {
3402           if (preserve_dates)
3403             set_times (tmpname, &statbuf);
3404           if (output_file != tmpname)
3405             status = (smart_rename (tmpname,
3406                                     output_file ? output_file : argv[i],
3407                                     preserve_dates) != 0);
3408           if (status == 0)
3409             status = hold_status;
3410         }
3411       else
3412         unlink_if_ordinary (tmpname);
3413       if (output_file != tmpname)
3414         free (tmpname);
3415     }
3416
3417   return status;
3418 }
3419
3420 /* Set up PE subsystem.  */
3421
3422 static void
3423 set_pe_subsystem (const char *s)
3424 {
3425   const char *version, *subsystem;
3426   size_t i;
3427   static const struct
3428     {
3429       const char *name;
3430       const char set_def;
3431       const short value;
3432     }
3433   v[] =
3434     {
3435       { "native", 0, IMAGE_SUBSYSTEM_NATIVE },
3436       { "windows", 0, IMAGE_SUBSYSTEM_WINDOWS_GUI },
3437       { "console", 0, IMAGE_SUBSYSTEM_WINDOWS_CUI },
3438       { "posix", 0, IMAGE_SUBSYSTEM_POSIX_CUI },
3439       { "wince", 0, IMAGE_SUBSYSTEM_WINDOWS_CE_GUI },
3440       { "efi-app", 1, IMAGE_SUBSYSTEM_EFI_APPLICATION },
3441       { "efi-bsd", 1, IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER },
3442       { "efi-rtd", 1, IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER },
3443       { "sal-rtd", 1, IMAGE_SUBSYSTEM_SAL_RUNTIME_DRIVER },
3444       { "xbox", 0, IMAGE_SUBSYSTEM_XBOX }
3445     };
3446   short value;
3447   char *copy;
3448   int set_def = -1;
3449
3450   /* Check for the presence of a version number.  */
3451   version = strchr (s, ':');
3452   if (version == NULL)
3453     subsystem = s;
3454   else
3455     {
3456       int len = version - s;
3457       copy = xstrdup (s);
3458       subsystem = copy;
3459       copy[len] = '\0';
3460       version = copy + 1 + len;
3461       pe_major_subsystem_version = strtoul (version, &copy, 0);
3462       if (*copy == '.')
3463         pe_minor_subsystem_version = strtoul (copy + 1, &copy, 0);
3464       if (*copy != '\0')
3465         non_fatal (_("%s: bad version in PE subsystem"), s);
3466     }
3467
3468   /* Check for numeric subsystem.  */
3469   value = (short) strtol (subsystem, &copy, 0);
3470   if (*copy == '\0')
3471     {
3472       for (i = 0; i < ARRAY_SIZE (v); i++)
3473         if (v[i].value == value)
3474           {
3475             pe_subsystem = value;
3476             set_def = v[i].set_def;
3477             break;
3478           }
3479     }
3480   else
3481     {
3482       /* Search for subsystem by name.  */
3483       for (i = 0; i < ARRAY_SIZE (v); i++)
3484         if (strcmp (subsystem, v[i].name) == 0)
3485           {
3486             pe_subsystem = v[i].value;
3487             set_def = v[i].set_def;
3488             break;
3489           }
3490     }
3491
3492   switch (set_def)
3493     {
3494     case -1:
3495       fatal (_("unknown PE subsystem: %s"), s);
3496       break;
3497     case 0:
3498       break;
3499     default:
3500       if (pe_file_alignment == (bfd_vma) -1)
3501         pe_file_alignment = PE_DEF_FILE_ALIGNMENT;
3502       if (pe_section_alignment == (bfd_vma) -1)
3503         pe_section_alignment = PE_DEF_SECTION_ALIGNMENT;
3504       break;
3505     }
3506   if (s != subsystem)
3507     free ((char *) subsystem);
3508 }
3509
3510 /* Convert EFI target to PEI target.  */
3511
3512 static void
3513 convert_efi_target (char *efi)
3514 {
3515   efi[0] = 'p';
3516   efi[1] = 'e';
3517   efi[2] = 'i';
3518
3519   if (strcmp (efi + 4, "ia32") == 0)
3520     {
3521       /* Change ia32 to i386.  */
3522       efi[5]= '3';
3523       efi[6]= '8';
3524       efi[7]= '6';
3525     }
3526   else if (strcmp (efi + 4, "x86_64") == 0)
3527     {
3528       /* Change x86_64 to x86-64.  */
3529       efi[7] = '-';
3530     }
3531 }
3532
3533 static int
3534 copy_main (int argc, char *argv[])
3535 {
3536   char *input_filename = NULL;
3537   char *output_filename = NULL;
3538   char *tmpname;
3539   char *input_target = NULL;
3540   char *output_target = NULL;
3541   bfd_boolean show_version = FALSE;
3542   bfd_boolean change_warn = TRUE;
3543   bfd_boolean formats_info = FALSE;
3544   int c;
3545   struct stat statbuf;
3546   const bfd_arch_info_type *input_arch = NULL;
3547
3548   while ((c = getopt_long (argc, argv, "b:B:i:I:j:K:N:s:O:d:F:L:G:R:SpgxXHhVvW:w",
3549                            copy_options, (int *) 0)) != EOF)
3550     {
3551       switch (c)
3552         {
3553         case 'b':
3554           copy_byte = atoi (optarg);
3555           if (copy_byte < 0)
3556             fatal (_("byte number must be non-negative"));
3557           break;
3558
3559         case 'B':
3560           input_arch = bfd_scan_arch (optarg);
3561           if (input_arch == NULL)
3562             fatal (_("architecture %s unknown"), optarg);
3563           break;
3564
3565         case 'i':
3566           if (optarg)
3567             {
3568               interleave = atoi (optarg);
3569               if (interleave < 1)
3570                 fatal (_("interleave must be positive"));
3571             }
3572           else
3573             interleave = 4;
3574           break;
3575
3576         case OPTION_INTERLEAVE_WIDTH:
3577           copy_width = atoi (optarg);
3578           if (copy_width < 1)
3579             fatal(_("interleave width must be positive"));
3580           break;
3581
3582         case 'I':
3583         case 's':               /* "source" - 'I' is preferred */
3584           input_target = optarg;
3585           break;
3586
3587         case 'O':
3588         case 'd':               /* "destination" - 'O' is preferred */
3589           output_target = optarg;
3590           break;
3591
3592         case 'F':
3593           input_target = output_target = optarg;
3594           break;
3595
3596         case 'j':
3597           find_section_list (optarg, TRUE, SECTION_CONTEXT_COPY);
3598           sections_copied = TRUE;
3599           break;
3600
3601         case 'R':
3602           find_section_list (optarg, TRUE, SECTION_CONTEXT_REMOVE);
3603           sections_removed = TRUE;
3604           break;
3605
3606         case 'S':
3607           strip_symbols = STRIP_ALL;
3608           break;
3609
3610         case 'g':
3611           strip_symbols = STRIP_DEBUG;
3612           break;
3613
3614         case OPTION_STRIP_DWO:
3615           strip_symbols = STRIP_DWO;
3616           break;
3617
3618         case OPTION_STRIP_UNNEEDED:
3619           strip_symbols = STRIP_UNNEEDED;
3620           break;
3621
3622         case OPTION_ONLY_KEEP_DEBUG:
3623           strip_symbols = STRIP_NONDEBUG;
3624           break;
3625
3626         case OPTION_KEEP_FILE_SYMBOLS:
3627           keep_file_symbols = 1;
3628           break;
3629
3630         case OPTION_ADD_GNU_DEBUGLINK:
3631           long_section_names = ENABLE ;
3632           gnu_debuglink_filename = optarg;
3633           break;
3634
3635         case 'K':
3636           add_specific_symbol (optarg, keep_specific_htab);
3637           break;
3638
3639         case 'N':
3640           add_specific_symbol (optarg, strip_specific_htab);
3641           break;
3642
3643         case OPTION_STRIP_UNNEEDED_SYMBOL:
3644           add_specific_symbol (optarg, strip_unneeded_htab);
3645           break;
3646
3647         case 'L':
3648           add_specific_symbol (optarg, localize_specific_htab);
3649           break;
3650
3651         case OPTION_GLOBALIZE_SYMBOL:
3652           add_specific_symbol (optarg, globalize_specific_htab);
3653           break;
3654
3655         case 'G':
3656           add_specific_symbol (optarg, keepglobal_specific_htab);
3657           break;
3658
3659         case 'W':
3660           add_specific_symbol (optarg, weaken_specific_htab);
3661           break;
3662
3663         case 'p':
3664           preserve_dates = TRUE;
3665           break;
3666
3667         case 'D':
3668           deterministic = TRUE;
3669           break;
3670
3671         case 'U':
3672           deterministic = FALSE;
3673           break;
3674
3675         case 'w':
3676           wildcard = TRUE;
3677           break;
3678
3679         case 'x':
3680           discard_locals = LOCALS_ALL;
3681           break;
3682
3683         case 'X':
3684           discard_locals = LOCALS_START_L;
3685           break;
3686
3687         case 'v':
3688           verbose = TRUE;
3689           break;
3690
3691         case 'V':
3692           show_version = TRUE;
3693           break;
3694
3695         case OPTION_FORMATS_INFO:
3696           formats_info = TRUE;
3697           break;
3698
3699         case OPTION_WEAKEN:
3700           weaken = TRUE;
3701           break;
3702
3703         case OPTION_ADD_SECTION:
3704           {
3705             const char *s;
3706             size_t off, alloc;
3707             struct section_add *pa;
3708             FILE *f;
3709
3710             s = strchr (optarg, '=');
3711
3712             if (s == NULL)
3713               fatal (_("bad format for %s"), "--add-section");
3714
3715             pa = (struct section_add *) xmalloc (sizeof (struct section_add));
3716             pa->name = xstrndup (optarg, s - optarg);
3717             pa->filename = s + 1;
3718
3719             /* We don't use get_file_size so that we can do
3720                  --add-section .note.GNU_stack=/dev/null
3721                get_file_size doesn't work on /dev/null.  */
3722
3723             f = fopen (pa->filename, FOPEN_RB);
3724             if (f == NULL)
3725               fatal (_("cannot open: %s: %s"),
3726                      pa->filename, strerror (errno));
3727
3728             off = 0;
3729             alloc = 4096;
3730             pa->contents = (bfd_byte *) xmalloc (alloc);
3731             while (!feof (f))
3732               {
3733                 off_t got;
3734
3735                 if (off == alloc)
3736                   {
3737                     alloc <<= 1;
3738                     pa->contents = (bfd_byte *) xrealloc (pa->contents, alloc);
3739                   }
3740
3741                 got = fread (pa->contents + off, 1, alloc - off, f);
3742                 if (ferror (f))
3743                   fatal (_("%s: fread failed"), pa->filename);
3744
3745                 off += got;
3746               }
3747
3748             pa->size = off;
3749
3750             fclose (f);
3751
3752             pa->next = add_sections;
3753             add_sections = pa;
3754           }
3755           break;
3756
3757         case OPTION_DUMP_SECTION:
3758           {
3759             const char *s;
3760             struct section_add *pa;
3761
3762             s = strchr (optarg, '=');
3763
3764             if (s == NULL)
3765               fatal (_("bad format for %s"), "--dump-section");
3766
3767             pa = (struct section_add *) xmalloc (sizeof * pa);
3768             pa->name = xstrndup (optarg, s - optarg);
3769             pa->filename = s + 1;
3770             pa->next = dump_sections;
3771             pa->contents = NULL;
3772             dump_sections = pa;
3773           }
3774           break;
3775           
3776         case OPTION_CHANGE_START:
3777           change_start = parse_vma (optarg, "--change-start");
3778           break;
3779
3780         case OPTION_CHANGE_SECTION_ADDRESS:
3781         case OPTION_CHANGE_SECTION_LMA:
3782         case OPTION_CHANGE_SECTION_VMA:
3783           {
3784             struct section_list * p;
3785             unsigned int context = 0;
3786             const char *s;
3787             int len;
3788             char *name;
3789             char *option = NULL;
3790             bfd_vma val;
3791
3792             switch (c)
3793               {
3794               case OPTION_CHANGE_SECTION_ADDRESS:
3795                 option = "--change-section-address";
3796                 context = SECTION_CONTEXT_ALTER_LMA | SECTION_CONTEXT_ALTER_VMA;
3797                 break;
3798               case OPTION_CHANGE_SECTION_LMA:
3799                 option = "--change-section-lma";
3800                 context = SECTION_CONTEXT_ALTER_LMA;
3801                 break;
3802               case OPTION_CHANGE_SECTION_VMA:
3803                 option = "--change-section-vma";
3804                 context = SECTION_CONTEXT_ALTER_VMA;
3805                 break;
3806               }
3807
3808             s = strchr (optarg, '=');
3809             if (s == NULL)
3810               {
3811                 s = strchr (optarg, '+');
3812                 if (s == NULL)
3813                   {
3814                     s = strchr (optarg, '-');
3815                     if (s == NULL)
3816                       fatal (_("bad format for %s"), option);
3817                   }
3818               }
3819             else
3820               {
3821                 /* Correct the context.  */
3822                 switch (c)
3823                   {
3824                   case OPTION_CHANGE_SECTION_ADDRESS:
3825                     context = SECTION_CONTEXT_SET_LMA | SECTION_CONTEXT_SET_VMA;
3826                     break;
3827                   case OPTION_CHANGE_SECTION_LMA:
3828                     context = SECTION_CONTEXT_SET_LMA;
3829                     break;
3830                   case OPTION_CHANGE_SECTION_VMA:
3831                     context = SECTION_CONTEXT_SET_VMA;
3832                     break;
3833                   }
3834               }
3835
3836             len = s - optarg;
3837             name = (char *) xmalloc (len + 1);
3838             strncpy (name, optarg, len);
3839             name[len] = '\0';
3840
3841             p = find_section_list (name, TRUE, context);
3842
3843             val = parse_vma (s + 1, option);
3844             if (*s == '-')
3845               val = - val;
3846
3847             switch (c)
3848               {
3849               case OPTION_CHANGE_SECTION_ADDRESS:
3850                 p->vma_val = val;
3851                 /* Drop through.  */
3852
3853               case OPTION_CHANGE_SECTION_LMA:
3854                 p->lma_val = val;
3855                 break;
3856
3857               case OPTION_CHANGE_SECTION_VMA:
3858                 p->vma_val = val;
3859                 break;
3860               }
3861           }
3862           break;
3863
3864         case OPTION_CHANGE_ADDRESSES:
3865           change_section_address = parse_vma (optarg, "--change-addresses");
3866           change_start = change_section_address;
3867           break;
3868
3869         case OPTION_CHANGE_WARNINGS:
3870           change_warn = TRUE;
3871           break;
3872
3873         case OPTION_CHANGE_LEADING_CHAR:
3874           change_leading_char = TRUE;
3875           break;
3876
3877         case OPTION_COMPRESS_DEBUG_SECTIONS:
3878           do_debug_sections = compress;
3879           break;
3880
3881         case OPTION_DEBUGGING:
3882           convert_debugging = TRUE;
3883           break;
3884
3885         case OPTION_DECOMPRESS_DEBUG_SECTIONS:
3886           do_debug_sections = decompress;
3887           break;
3888
3889         case OPTION_GAP_FILL:
3890           {
3891             bfd_vma gap_fill_vma;
3892
3893             gap_fill_vma = parse_vma (optarg, "--gap-fill");
3894             gap_fill = (bfd_byte) gap_fill_vma;
3895             if ((bfd_vma) gap_fill != gap_fill_vma)
3896               {
3897                 char buff[20];
3898
3899                 sprintf_vma (buff, gap_fill_vma);
3900
3901                 non_fatal (_("Warning: truncating gap-fill from 0x%s to 0x%x"),
3902                            buff, gap_fill);
3903               }
3904             gap_fill_set = TRUE;
3905           }
3906           break;
3907
3908         case OPTION_NO_CHANGE_WARNINGS:
3909           change_warn = FALSE;
3910           break;
3911
3912         case OPTION_PAD_TO:
3913           pad_to = parse_vma (optarg, "--pad-to");
3914           pad_to_set = TRUE;
3915           break;
3916
3917         case OPTION_REMOVE_LEADING_CHAR:
3918           remove_leading_char = TRUE;
3919           break;
3920
3921         case OPTION_REDEFINE_SYM:
3922           {
3923             /* Push this redefinition onto redefine_symbol_list.  */
3924
3925             int len;
3926             const char *s;
3927             const char *nextarg;
3928             char *source, *target;
3929
3930             s = strchr (optarg, '=');
3931             if (s == NULL)
3932               fatal (_("bad format for %s"), "--redefine-sym");
3933
3934             len = s - optarg;
3935             source = (char *) xmalloc (len + 1);
3936             strncpy (source, optarg, len);
3937             source[len] = '\0';
3938
3939             nextarg = s + 1;
3940             len = strlen (nextarg);