Stop objcopy from attempting to copy thin archives.
[external/binutils.git] / binutils / objcopy.c
1 /* objcopy.c -- copy object file from input to output, optionally massaging it.
2    Copyright (C) 1991-2019 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 "coff/internal.h"
32 #include "libcoff.h"
33 #include "safe-ctype.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 node includes symbol name mapping to support redefine_sym.  */
58 struct redefine_node
59 {
60   char *source;
61   char *target;
62 };
63
64 struct addsym_node
65 {
66   struct addsym_node *next;
67   char *    symdef;
68   long      symval;
69   flagword  flags;
70   char *    section;
71   char *    othersym;
72 };
73
74 typedef struct section_rename
75 {
76   const char *            old_name;
77   const char *            new_name;
78   flagword                flags;
79   struct section_rename * next;
80 }
81 section_rename;
82
83 /* List of sections to be renamed.  */
84 static section_rename *section_rename_list;
85
86 static asymbol **isympp = NULL; /* Input symbols.  */
87 static asymbol **osympp = NULL; /* Output symbols that survive stripping.  */
88
89 /* If `copy_byte' >= 0, copy 'copy_width' byte(s) of every `interleave' bytes.  */
90 static int copy_byte = -1;
91 static int interleave = 0; /* Initialised to 4 in copy_main().  */
92 static int copy_width = 1;
93
94 static bfd_boolean verbose;             /* Print file and target names.  */
95 static bfd_boolean preserve_dates;      /* Preserve input file timestamp.  */
96 static int deterministic = -1;          /* Enable deterministic archives.  */
97 static int status = 0;                  /* Exit status.  */
98
99 static bfd_boolean    merge_notes = FALSE;      /* Merge note sections.  */
100 static bfd_byte *     merged_notes = NULL;      /* Contents on note section undergoing a merge.  */
101 static bfd_size_type  merged_size = 0;          /* New, smaller size of the merged note section.  */
102
103 enum strip_action
104 {
105   STRIP_UNDEF,
106   STRIP_NONE,           /* Don't strip.  */
107   STRIP_DEBUG,          /* Strip all debugger symbols.  */
108   STRIP_UNNEEDED,       /* Strip unnecessary symbols.  */
109   STRIP_NONDEBUG,       /* Strip everything but debug info.  */
110   STRIP_DWO,            /* Strip all DWO info.  */
111   STRIP_NONDWO,         /* Strip everything but DWO info.  */
112   STRIP_ALL             /* Strip all symbols.  */
113 };
114
115 /* Which symbols to remove.  */
116 static enum strip_action strip_symbols = STRIP_UNDEF;
117
118 enum locals_action
119 {
120   LOCALS_UNDEF,
121   LOCALS_START_L,       /* Discard locals starting with L.  */
122   LOCALS_ALL            /* Discard all locals.  */
123 };
124
125 /* Which local symbols to remove.  Overrides STRIP_ALL.  */
126 static enum locals_action discard_locals;
127
128 /* Structure used to hold lists of sections and actions to take.  */
129 struct section_list
130 {
131   struct section_list * next;      /* Next section to change.  */
132   const char *          pattern;   /* Section name pattern.  */
133   bfd_boolean           used;      /* Whether this entry was used.  */
134
135   unsigned int          context;   /* What to do with matching sections.  */
136   /* Flag bits used in the context field.
137      COPY and REMOVE are mutually exlusive.  SET and ALTER are mutually exclusive.  */
138 #define SECTION_CONTEXT_REMOVE    (1 << 0) /* Remove this section.  */
139 #define SECTION_CONTEXT_COPY      (1 << 1) /* Copy this section, delete all non-copied section.  */
140 #define SECTION_CONTEXT_SET_VMA   (1 << 2) /* Set the sections' VMA address.  */
141 #define SECTION_CONTEXT_ALTER_VMA (1 << 3) /* Increment or decrement the section's VMA address.  */
142 #define SECTION_CONTEXT_SET_LMA   (1 << 4) /* Set the sections' LMA address.  */
143 #define SECTION_CONTEXT_ALTER_LMA (1 << 5) /* Increment or decrement the section's LMA address.  */
144 #define SECTION_CONTEXT_SET_FLAGS (1 << 6) /* Set the section's flags.  */
145 #define SECTION_CONTEXT_REMOVE_RELOCS (1 << 7) /* Remove relocations for this section.  */
146
147   bfd_vma               vma_val;   /* Amount to change by or set to.  */
148   bfd_vma               lma_val;   /* Amount to change by or set to.  */
149   flagword              flags;     /* What to set the section flags to.  */
150 };
151
152 static struct section_list *change_sections;
153
154 /* TRUE if some sections are to be removed.  */
155 static bfd_boolean sections_removed;
156
157 /* TRUE if only some sections are to be copied.  */
158 static bfd_boolean sections_copied;
159
160 /* Changes to the start address.  */
161 static bfd_vma change_start = 0;
162 static bfd_boolean set_start_set = FALSE;
163 static bfd_vma set_start;
164
165 /* Changes to section addresses.  */
166 static bfd_vma change_section_address = 0;
167
168 /* Filling gaps between sections.  */
169 static bfd_boolean gap_fill_set = FALSE;
170 static bfd_byte gap_fill = 0;
171
172 /* Pad to a given address.  */
173 static bfd_boolean pad_to_set = FALSE;
174 static bfd_vma pad_to;
175
176 /* Use alternative machine code?  */
177 static unsigned long use_alt_mach_code = 0;
178
179 /* Output BFD flags user wants to set or clear */
180 static flagword bfd_flags_to_set;
181 static flagword bfd_flags_to_clear;
182
183 /* List of sections to add.  */
184 struct section_add
185 {
186   /* Next section to add.  */
187   struct section_add *next;
188   /* Name of section to add.  */
189   const char *name;
190   /* Name of file holding section contents.  */
191   const char *filename;
192   /* Size of file.  */
193   size_t size;
194   /* Contents of file.  */
195   bfd_byte *contents;
196   /* BFD section, after it has been added.  */
197   asection *section;
198 };
199
200 /* List of sections to add to the output BFD.  */
201 static struct section_add *add_sections;
202
203 /* List of sections to update in the output BFD.  */
204 static struct section_add *update_sections;
205
206 /* List of sections to dump from the output BFD.  */
207 static struct section_add *dump_sections;
208
209 /* If non-NULL the argument to --add-gnu-debuglink.
210    This should be the filename to store in the .gnu_debuglink section.  */
211 static const char * gnu_debuglink_filename = NULL;
212
213 /* Whether to convert debugging information.  */
214 static bfd_boolean convert_debugging = FALSE;
215
216 /* Whether to compress/decompress DWARF debug sections.  */
217 static enum
218 {
219   nothing = 0,
220   compress = 1 << 0,
221   compress_zlib = compress | 1 << 1,
222   compress_gnu_zlib = compress | 1 << 2,
223   compress_gabi_zlib = compress | 1 << 3,
224   decompress = 1 << 4
225 } do_debug_sections = nothing;
226
227 /* Whether to generate ELF common symbols with the STT_COMMON type.  */
228 static enum bfd_link_elf_stt_common do_elf_stt_common = unchanged;
229
230 /* Whether to change the leading character in symbol names.  */
231 static bfd_boolean change_leading_char = FALSE;
232
233 /* Whether to remove the leading character from global symbol names.  */
234 static bfd_boolean remove_leading_char = FALSE;
235
236 /* Whether to permit wildcard in symbol comparison.  */
237 static bfd_boolean wildcard = FALSE;
238
239 /* True if --localize-hidden is in effect.  */
240 static bfd_boolean localize_hidden = FALSE;
241
242 /* List of symbols to strip, keep, localize, keep-global, weaken,
243    or redefine.  */
244 static htab_t strip_specific_htab = NULL;
245 static htab_t strip_unneeded_htab = NULL;
246 static htab_t keep_specific_htab = NULL;
247 static htab_t localize_specific_htab = NULL;
248 static htab_t globalize_specific_htab = NULL;
249 static htab_t keepglobal_specific_htab = NULL;
250 static htab_t weaken_specific_htab = NULL;
251 static htab_t redefine_specific_htab = NULL;
252 static htab_t redefine_specific_reverse_htab = NULL;
253 static struct addsym_node *add_sym_list = NULL, **add_sym_tail = &add_sym_list;
254 static int add_symbols = 0;
255
256 static char *strip_specific_buffer = NULL;
257 static char *strip_unneeded_buffer = NULL;
258 static char *keep_specific_buffer = NULL;
259 static char *localize_specific_buffer = NULL;
260 static char *globalize_specific_buffer = NULL;
261 static char *keepglobal_specific_buffer = NULL;
262 static char *weaken_specific_buffer = NULL;
263
264 /* If this is TRUE, we weaken global symbols (set BSF_WEAK).  */
265 static bfd_boolean weaken = FALSE;
266
267 /* If this is TRUE, we retain BSF_FILE symbols.  */
268 static bfd_boolean keep_file_symbols = FALSE;
269
270 /* Prefix symbols/sections.  */
271 static char *prefix_symbols_string = 0;
272 static char *prefix_sections_string = 0;
273 static char *prefix_alloc_sections_string = 0;
274
275 /* True if --extract-symbol was passed on the command line.  */
276 static bfd_boolean extract_symbol = FALSE;
277
278 /* If `reverse_bytes' is nonzero, then reverse the order of every chunk
279    of <reverse_bytes> bytes within each output section.  */
280 static int reverse_bytes = 0;
281
282 /* For Coff objects, we may want to allow or disallow long section names,
283    or preserve them where found in the inputs.  Debug info relies on them.  */
284 enum long_section_name_handling
285 {
286   DISABLE,
287   ENABLE,
288   KEEP
289 };
290
291 /* The default long section handling mode is to preserve them.
292    This is also the only behaviour for 'strip'.  */
293 static enum long_section_name_handling long_section_names = KEEP;
294
295 /* 150 isn't special; it's just an arbitrary non-ASCII char value.  */
296 enum command_line_switch
297 {
298   OPTION_ADD_SECTION=150,
299   OPTION_ADD_GNU_DEBUGLINK,
300   OPTION_ADD_SYMBOL,
301   OPTION_ALT_MACH_CODE,
302   OPTION_CHANGE_ADDRESSES,
303   OPTION_CHANGE_LEADING_CHAR,
304   OPTION_CHANGE_SECTION_ADDRESS,
305   OPTION_CHANGE_SECTION_LMA,
306   OPTION_CHANGE_SECTION_VMA,
307   OPTION_CHANGE_START,
308   OPTION_CHANGE_WARNINGS,
309   OPTION_COMPRESS_DEBUG_SECTIONS,
310   OPTION_DEBUGGING,
311   OPTION_DECOMPRESS_DEBUG_SECTIONS,
312   OPTION_DUMP_SECTION,
313   OPTION_ELF_STT_COMMON,
314   OPTION_EXTRACT_DWO,
315   OPTION_EXTRACT_SYMBOL,
316   OPTION_FILE_ALIGNMENT,
317   OPTION_FORMATS_INFO,
318   OPTION_GAP_FILL,
319   OPTION_GLOBALIZE_SYMBOL,
320   OPTION_GLOBALIZE_SYMBOLS,
321   OPTION_HEAP,
322   OPTION_IMAGE_BASE,
323   OPTION_IMPURE,
324   OPTION_INTERLEAVE_WIDTH,
325   OPTION_KEEPGLOBAL_SYMBOLS,
326   OPTION_KEEP_FILE_SYMBOLS,
327   OPTION_KEEP_SYMBOLS,
328   OPTION_LOCALIZE_HIDDEN,
329   OPTION_LOCALIZE_SYMBOLS,
330   OPTION_LONG_SECTION_NAMES,
331   OPTION_MERGE_NOTES,
332   OPTION_NO_MERGE_NOTES,
333   OPTION_NO_CHANGE_WARNINGS,
334   OPTION_ONLY_KEEP_DEBUG,
335   OPTION_PAD_TO,
336   OPTION_PREFIX_ALLOC_SECTIONS,
337   OPTION_PREFIX_SECTIONS,
338   OPTION_PREFIX_SYMBOLS,
339   OPTION_PURE,
340   OPTION_READONLY_TEXT,
341   OPTION_REDEFINE_SYM,
342   OPTION_REDEFINE_SYMS,
343   OPTION_REMOVE_LEADING_CHAR,
344   OPTION_REMOVE_RELOCS,
345   OPTION_RENAME_SECTION,
346   OPTION_REVERSE_BYTES,
347   OPTION_SECTION_ALIGNMENT,
348   OPTION_SET_SECTION_FLAGS,
349   OPTION_SET_START,
350   OPTION_SREC_FORCES3,
351   OPTION_SREC_LEN,
352   OPTION_STACK,
353   OPTION_STRIP_DWO,
354   OPTION_STRIP_SYMBOLS,
355   OPTION_STRIP_UNNEEDED,
356   OPTION_STRIP_UNNEEDED_SYMBOL,
357   OPTION_STRIP_UNNEEDED_SYMBOLS,
358   OPTION_SUBSYSTEM,
359   OPTION_UPDATE_SECTION,
360   OPTION_WEAKEN,
361   OPTION_WEAKEN_SYMBOLS,
362   OPTION_WRITABLE_TEXT
363 };
364
365 /* Options to handle if running as "strip".  */
366
367 static struct option strip_options[] =
368 {
369   {"disable-deterministic-archives", no_argument, 0, 'U'},
370   {"discard-all", no_argument, 0, 'x'},
371   {"discard-locals", no_argument, 0, 'X'},
372   {"enable-deterministic-archives", no_argument, 0, 'D'},
373   {"format", required_argument, 0, 'F'}, /* Obsolete */
374   {"help", no_argument, 0, 'h'},
375   {"info", no_argument, 0, OPTION_FORMATS_INFO},
376   {"input-format", required_argument, 0, 'I'}, /* Obsolete */
377   {"input-target", required_argument, 0, 'I'},
378   {"keep-file-symbols", no_argument, 0, OPTION_KEEP_FILE_SYMBOLS},
379   {"keep-symbol", required_argument, 0, 'K'},
380   {"merge-notes", no_argument, 0, 'M'},
381   {"no-merge-notes", no_argument, 0, OPTION_NO_MERGE_NOTES},
382   {"only-keep-debug", no_argument, 0, OPTION_ONLY_KEEP_DEBUG},
383   {"output-file", required_argument, 0, 'o'},
384   {"output-format", required_argument, 0, 'O'}, /* Obsolete */
385   {"output-target", required_argument, 0, 'O'},
386   {"preserve-dates", no_argument, 0, 'p'},
387   {"remove-section", required_argument, 0, 'R'},
388   {"remove-relocations", required_argument, 0, OPTION_REMOVE_RELOCS},
389   {"strip-all", no_argument, 0, 's'},
390   {"strip-debug", no_argument, 0, 'S'},
391   {"strip-dwo", no_argument, 0, OPTION_STRIP_DWO},
392   {"strip-symbol", required_argument, 0, 'N'},
393   {"strip-unneeded", no_argument, 0, OPTION_STRIP_UNNEEDED},
394   {"target", required_argument, 0, 'F'},
395   {"verbose", no_argument, 0, 'v'},
396   {"version", no_argument, 0, 'V'},
397   {"wildcard", no_argument, 0, 'w'},
398   {0, no_argument, 0, 0}
399 };
400
401 /* Options to handle if running as "objcopy".  */
402
403 static struct option copy_options[] =
404 {
405   {"add-gnu-debuglink", required_argument, 0, OPTION_ADD_GNU_DEBUGLINK},
406   {"add-section", required_argument, 0, OPTION_ADD_SECTION},
407   {"add-symbol", required_argument, 0, OPTION_ADD_SYMBOL},
408   {"adjust-section-vma", required_argument, 0, OPTION_CHANGE_SECTION_ADDRESS},
409   {"adjust-start", required_argument, 0, OPTION_CHANGE_START},
410   {"adjust-vma", required_argument, 0, OPTION_CHANGE_ADDRESSES},
411   {"adjust-warnings", no_argument, 0, OPTION_CHANGE_WARNINGS},
412   {"alt-machine-code", required_argument, 0, OPTION_ALT_MACH_CODE},
413   {"binary-architecture", required_argument, 0, 'B'},
414   {"byte", required_argument, 0, 'b'},
415   {"change-addresses", required_argument, 0, OPTION_CHANGE_ADDRESSES},
416   {"change-leading-char", no_argument, 0, OPTION_CHANGE_LEADING_CHAR},
417   {"change-section-address", required_argument, 0, OPTION_CHANGE_SECTION_ADDRESS},
418   {"change-section-lma", required_argument, 0, OPTION_CHANGE_SECTION_LMA},
419   {"change-section-vma", required_argument, 0, OPTION_CHANGE_SECTION_VMA},
420   {"change-start", required_argument, 0, OPTION_CHANGE_START},
421   {"change-warnings", no_argument, 0, OPTION_CHANGE_WARNINGS},
422   {"compress-debug-sections", optional_argument, 0, OPTION_COMPRESS_DEBUG_SECTIONS},
423   {"debugging", no_argument, 0, OPTION_DEBUGGING},
424   {"decompress-debug-sections", no_argument, 0, OPTION_DECOMPRESS_DEBUG_SECTIONS},
425   {"disable-deterministic-archives", no_argument, 0, 'U'},
426   {"discard-all", no_argument, 0, 'x'},
427   {"discard-locals", no_argument, 0, 'X'},
428   {"dump-section", required_argument, 0, OPTION_DUMP_SECTION},
429   {"elf-stt-common", required_argument, 0, OPTION_ELF_STT_COMMON},
430   {"enable-deterministic-archives", no_argument, 0, 'D'},
431   {"extract-dwo", no_argument, 0, OPTION_EXTRACT_DWO},
432   {"extract-symbol", no_argument, 0, OPTION_EXTRACT_SYMBOL},
433   {"file-alignment", required_argument, 0, OPTION_FILE_ALIGNMENT},
434   {"format", required_argument, 0, 'F'}, /* Obsolete */
435   {"gap-fill", required_argument, 0, OPTION_GAP_FILL},
436   {"globalize-symbol", required_argument, 0, OPTION_GLOBALIZE_SYMBOL},
437   {"globalize-symbols", required_argument, 0, OPTION_GLOBALIZE_SYMBOLS},
438   {"heap", required_argument, 0, OPTION_HEAP},
439   {"help", no_argument, 0, 'h'},
440   {"image-base", required_argument, 0 , OPTION_IMAGE_BASE},
441   {"impure", no_argument, 0, OPTION_IMPURE},
442   {"info", no_argument, 0, OPTION_FORMATS_INFO},
443   {"input-format", required_argument, 0, 'I'}, /* Obsolete */
444   {"input-target", required_argument, 0, 'I'},
445   {"interleave", optional_argument, 0, 'i'},
446   {"interleave-width", required_argument, 0, OPTION_INTERLEAVE_WIDTH},
447   {"keep-file-symbols", no_argument, 0, OPTION_KEEP_FILE_SYMBOLS},
448   {"keep-global-symbol", required_argument, 0, 'G'},
449   {"keep-global-symbols", required_argument, 0, OPTION_KEEPGLOBAL_SYMBOLS},
450   {"keep-symbol", required_argument, 0, 'K'},
451   {"keep-symbols", required_argument, 0, OPTION_KEEP_SYMBOLS},
452   {"localize-hidden", no_argument, 0, OPTION_LOCALIZE_HIDDEN},
453   {"localize-symbol", required_argument, 0, 'L'},
454   {"localize-symbols", required_argument, 0, OPTION_LOCALIZE_SYMBOLS},
455   {"long-section-names", required_argument, 0, OPTION_LONG_SECTION_NAMES},
456   {"merge-notes", no_argument, 0, 'M'},
457   {"no-merge-notes", no_argument, 0, OPTION_NO_MERGE_NOTES},
458   {"no-adjust-warnings", no_argument, 0, OPTION_NO_CHANGE_WARNINGS},
459   {"no-change-warnings", no_argument, 0, OPTION_NO_CHANGE_WARNINGS},
460   {"only-keep-debug", no_argument, 0, OPTION_ONLY_KEEP_DEBUG},
461   {"only-section", required_argument, 0, 'j'},
462   {"output-format", required_argument, 0, 'O'}, /* Obsolete */
463   {"output-target", required_argument, 0, 'O'},
464   {"pad-to", required_argument, 0, OPTION_PAD_TO},
465   {"prefix-alloc-sections", required_argument, 0, OPTION_PREFIX_ALLOC_SECTIONS},
466   {"prefix-sections", required_argument, 0, OPTION_PREFIX_SECTIONS},
467   {"prefix-symbols", required_argument, 0, OPTION_PREFIX_SYMBOLS},
468   {"preserve-dates", no_argument, 0, 'p'},
469   {"pure", no_argument, 0, OPTION_PURE},
470   {"readonly-text", no_argument, 0, OPTION_READONLY_TEXT},
471   {"redefine-sym", required_argument, 0, OPTION_REDEFINE_SYM},
472   {"redefine-syms", required_argument, 0, OPTION_REDEFINE_SYMS},
473   {"remove-leading-char", no_argument, 0, OPTION_REMOVE_LEADING_CHAR},
474   {"remove-section", required_argument, 0, 'R'},
475   {"remove-relocations", required_argument, 0, OPTION_REMOVE_RELOCS},
476   {"rename-section", required_argument, 0, OPTION_RENAME_SECTION},
477   {"reverse-bytes", required_argument, 0, OPTION_REVERSE_BYTES},
478   {"section-alignment", required_argument, 0, OPTION_SECTION_ALIGNMENT},
479   {"set-section-flags", required_argument, 0, OPTION_SET_SECTION_FLAGS},
480   {"set-start", required_argument, 0, OPTION_SET_START},
481   {"srec-forceS3", no_argument, 0, OPTION_SREC_FORCES3},
482   {"srec-len", required_argument, 0, OPTION_SREC_LEN},
483   {"stack", required_argument, 0, OPTION_STACK},
484   {"strip-all", no_argument, 0, 'S'},
485   {"strip-debug", no_argument, 0, 'g'},
486   {"strip-dwo", no_argument, 0, OPTION_STRIP_DWO},
487   {"strip-symbol", required_argument, 0, 'N'},
488   {"strip-symbols", required_argument, 0, OPTION_STRIP_SYMBOLS},
489   {"strip-unneeded", no_argument, 0, OPTION_STRIP_UNNEEDED},
490   {"strip-unneeded-symbol", required_argument, 0, OPTION_STRIP_UNNEEDED_SYMBOL},
491   {"strip-unneeded-symbols", required_argument, 0, OPTION_STRIP_UNNEEDED_SYMBOLS},
492   {"subsystem", required_argument, 0, OPTION_SUBSYSTEM},
493   {"target", required_argument, 0, 'F'},
494   {"update-section", required_argument, 0, OPTION_UPDATE_SECTION},
495   {"verbose", no_argument, 0, 'v'},
496   {"version", no_argument, 0, 'V'},
497   {"weaken", no_argument, 0, OPTION_WEAKEN},
498   {"weaken-symbol", required_argument, 0, 'W'},
499   {"weaken-symbols", required_argument, 0, OPTION_WEAKEN_SYMBOLS},
500   {"wildcard", no_argument, 0, 'w'},
501   {"writable-text", no_argument, 0, OPTION_WRITABLE_TEXT},
502   {0, no_argument, 0, 0}
503 };
504
505 /* IMPORTS */
506 extern char *program_name;
507
508 /* This flag distinguishes between strip and objcopy:
509    1 means this is 'strip'; 0 means this is 'objcopy'.
510    -1 means if we should use argv[0] to decide.  */
511 extern int is_strip;
512
513 /* The maximum length of an S record.  This variable is defined in srec.c
514    and can be modified by the --srec-len parameter.  */
515 extern unsigned int _bfd_srec_len;
516
517 /* Restrict the generation of Srecords to type S3 only.
518    This variable is defined in bfd/srec.c and can be toggled
519    on by the --srec-forceS3 command line switch.  */
520 extern bfd_boolean _bfd_srec_forceS3;
521
522 /* Forward declarations.  */
523 static void setup_section (bfd *, asection *, void *);
524 static void setup_bfd_headers (bfd *, bfd *);
525 static void copy_relocations_in_section (bfd *, asection *, void *);
526 static void copy_section (bfd *, asection *, void *);
527 static void get_sections (bfd *, asection *, void *);
528 static int compare_section_lma (const void *, const void *);
529 static void mark_symbols_used_in_relocations (bfd *, asection *, void *);
530 static bfd_boolean write_debugging_info (bfd *, void *, long *, asymbol ***);
531 static const char *lookup_sym_redefinition (const char *);
532 static const char *find_section_rename (const char *, flagword *);
533 \f
534 ATTRIBUTE_NORETURN static void
535 copy_usage (FILE *stream, int exit_status)
536 {
537   fprintf (stream, _("Usage: %s [option(s)] in-file [out-file]\n"), program_name);
538   fprintf (stream, _(" Copies a binary file, possibly transforming it in the process\n"));
539   fprintf (stream, _(" The options are:\n"));
540   fprintf (stream, _("\
541   -I --input-target <bfdname>      Assume input file is in format <bfdname>\n\
542   -O --output-target <bfdname>     Create an output file in format <bfdname>\n\
543   -B --binary-architecture <arch>  Set output arch, when input is arch-less\n\
544   -F --target <bfdname>            Set both input and output format to <bfdname>\n\
545      --debugging                   Convert debugging information, if possible\n\
546   -p --preserve-dates              Copy modified/access timestamps to the output\n"));
547   if (DEFAULT_AR_DETERMINISTIC)
548     fprintf (stream, _("\
549   -D --enable-deterministic-archives\n\
550                                    Produce deterministic output when stripping archives (default)\n\
551   -U --disable-deterministic-archives\n\
552                                    Disable -D behavior\n"));
553   else
554     fprintf (stream, _("\
555   -D --enable-deterministic-archives\n\
556                                    Produce deterministic output when stripping archives\n\
557   -U --disable-deterministic-archives\n\
558                                    Disable -D behavior (default)\n"));
559   fprintf (stream, _("\
560   -j --only-section <name>         Only copy section <name> into the output\n\
561      --add-gnu-debuglink=<file>    Add section .gnu_debuglink linking to <file>\n\
562   -R --remove-section <name>       Remove section <name> from the output\n\
563      --remove-relocations <name>   Remove relocations from section <name>\n\
564   -S --strip-all                   Remove all symbol and relocation information\n\
565   -g --strip-debug                 Remove all debugging symbols & sections\n\
566      --strip-dwo                   Remove all DWO sections\n\
567      --strip-unneeded              Remove all symbols not needed by relocations\n\
568   -N --strip-symbol <name>         Do not copy symbol <name>\n\
569      --strip-unneeded-symbol <name>\n\
570                                    Do not copy symbol <name> unless needed by\n\
571                                      relocations\n\
572      --only-keep-debug             Strip everything but the debug information\n\
573      --extract-dwo                 Copy only DWO sections\n\
574      --extract-symbol              Remove section contents but keep symbols\n\
575   -K --keep-symbol <name>          Do not strip symbol <name>\n\
576      --keep-file-symbols           Do not strip file symbol(s)\n\
577      --localize-hidden             Turn all ELF hidden symbols into locals\n\
578   -L --localize-symbol <name>      Force symbol <name> to be marked as a local\n\
579      --globalize-symbol <name>     Force symbol <name> to be marked as a global\n\
580   -G --keep-global-symbol <name>   Localize all symbols except <name>\n\
581   -W --weaken-symbol <name>        Force symbol <name> to be marked as a weak\n\
582      --weaken                      Force all global symbols to be marked as weak\n\
583   -w --wildcard                    Permit wildcard in symbol comparison\n\
584   -x --discard-all                 Remove all non-global symbols\n\
585   -X --discard-locals              Remove any compiler-generated symbols\n\
586   -i --interleave[=<number>]       Only copy N out of every <number> bytes\n\
587      --interleave-width <number>   Set N for --interleave\n\
588   -b --byte <num>                  Select byte <num> in every interleaved block\n\
589      --gap-fill <val>              Fill gaps between sections with <val>\n\
590      --pad-to <addr>               Pad the last section up to address <addr>\n\
591      --set-start <addr>            Set the start address to <addr>\n\
592     {--change-start|--adjust-start} <incr>\n\
593                                    Add <incr> to the start address\n\
594     {--change-addresses|--adjust-vma} <incr>\n\
595                                    Add <incr> to LMA, VMA and start addresses\n\
596     {--change-section-address|--adjust-section-vma} <name>{=|+|-}<val>\n\
597                                    Change LMA and VMA of section <name> by <val>\n\
598      --change-section-lma <name>{=|+|-}<val>\n\
599                                    Change the LMA of section <name> by <val>\n\
600      --change-section-vma <name>{=|+|-}<val>\n\
601                                    Change the VMA of section <name> by <val>\n\
602     {--[no-]change-warnings|--[no-]adjust-warnings}\n\
603                                    Warn if a named section does not exist\n\
604      --set-section-flags <name>=<flags>\n\
605                                    Set section <name>'s properties to <flags>\n\
606      --add-section <name>=<file>   Add section <name> found in <file> to output\n\
607      --update-section <name>=<file>\n\
608                                    Update contents of section <name> with\n\
609                                    contents found in <file>\n\
610      --dump-section <name>=<file>  Dump the contents of section <name> into <file>\n\
611      --rename-section <old>=<new>[,<flags>] Rename section <old> to <new>\n\
612      --long-section-names {enable|disable|keep}\n\
613                                    Handle long section names in Coff objects.\n\
614      --change-leading-char         Force output format's leading character style\n\
615      --remove-leading-char         Remove leading character from global symbols\n\
616      --reverse-bytes=<num>         Reverse <num> bytes at a time, in output sections with content\n\
617      --redefine-sym <old>=<new>    Redefine symbol name <old> to <new>\n\
618      --redefine-syms <file>        --redefine-sym for all symbol pairs \n\
619                                      listed in <file>\n\
620      --srec-len <number>           Restrict the length of generated Srecords\n\
621      --srec-forceS3                Restrict the type of generated Srecords to S3\n\
622      --strip-symbols <file>        -N for all symbols listed in <file>\n\
623      --strip-unneeded-symbols <file>\n\
624                                    --strip-unneeded-symbol for all symbols listed\n\
625                                      in <file>\n\
626      --keep-symbols <file>         -K for all symbols listed in <file>\n\
627      --localize-symbols <file>     -L for all symbols listed in <file>\n\
628      --globalize-symbols <file>    --globalize-symbol for all in <file>\n\
629      --keep-global-symbols <file>  -G for all symbols listed in <file>\n\
630      --weaken-symbols <file>       -W for all symbols listed in <file>\n\
631      --add-symbol <name>=[<section>:]<value>[,<flags>]  Add a symbol\n\
632      --alt-machine-code <index>    Use the target's <index>'th alternative machine\n\
633      --writable-text               Mark the output text as writable\n\
634      --readonly-text               Make the output text write protected\n\
635      --pure                        Mark the output file as demand paged\n\
636      --impure                      Mark the output file as impure\n\
637      --prefix-symbols <prefix>     Add <prefix> to start of every symbol name\n\
638      --prefix-sections <prefix>    Add <prefix> to start of every section name\n\
639      --prefix-alloc-sections <prefix>\n\
640                                    Add <prefix> to start of every allocatable\n\
641                                      section name\n\
642      --file-alignment <num>        Set PE file alignment to <num>\n\
643      --heap <reserve>[,<commit>]   Set PE reserve/commit heap to <reserve>/\n\
644                                    <commit>\n\
645      --image-base <address>        Set PE image base to <address>\n\
646      --section-alignment <num>     Set PE section alignment to <num>\n\
647      --stack <reserve>[,<commit>]  Set PE reserve/commit stack to <reserve>/\n\
648                                    <commit>\n\
649      --subsystem <name>[:<version>]\n\
650                                    Set PE subsystem to <name> [& <version>]\n\
651      --compress-debug-sections[={none|zlib|zlib-gnu|zlib-gabi}]\n\
652                                    Compress DWARF debug sections using zlib\n\
653      --decompress-debug-sections   Decompress DWARF debug sections using zlib\n\
654      --elf-stt-common=[yes|no]     Generate ELF common symbols with STT_COMMON\n\
655                                      type\n\
656   -M  --merge-notes                Remove redundant entries in note sections\n\
657       --no-merge-notes             Do not attempt to remove redundant notes (default)\n\
658   -v --verbose                     List all object files modified\n\
659   @<file>                          Read options from <file>\n\
660   -V --version                     Display this program's version number\n\
661   -h --help                        Display this output\n\
662      --info                        List object formats & architectures supported\n\
663 "));
664   list_supported_targets (program_name, stream);
665   if (REPORT_BUGS_TO[0] && exit_status == 0)
666     fprintf (stream, _("Report bugs to %s\n"), REPORT_BUGS_TO);
667   exit (exit_status);
668 }
669
670 ATTRIBUTE_NORETURN static void
671 strip_usage (FILE *stream, int exit_status)
672 {
673   fprintf (stream, _("Usage: %s <option(s)> in-file(s)\n"), program_name);
674   fprintf (stream, _(" Removes symbols and sections from files\n"));
675   fprintf (stream, _(" The options are:\n"));
676   fprintf (stream, _("\
677   -I --input-target=<bfdname>      Assume input file is in format <bfdname>\n\
678   -O --output-target=<bfdname>     Create an output file in format <bfdname>\n\
679   -F --target=<bfdname>            Set both input and output format to <bfdname>\n\
680   -p --preserve-dates              Copy modified/access timestamps to the output\n\
681 "));
682   if (DEFAULT_AR_DETERMINISTIC)
683     fprintf (stream, _("\
684   -D --enable-deterministic-archives\n\
685                                    Produce deterministic output when stripping archives (default)\n\
686   -U --disable-deterministic-archives\n\
687                                    Disable -D behavior\n"));
688   else
689     fprintf (stream, _("\
690   -D --enable-deterministic-archives\n\
691                                    Produce deterministic output when stripping archives\n\
692   -U --disable-deterministic-archives\n\
693                                    Disable -D behavior (default)\n"));
694   fprintf (stream, _("\
695   -R --remove-section=<name>       Also remove section <name> from the output\n\
696      --remove-relocations <name>   Remove relocations from section <name>\n\
697   -s --strip-all                   Remove all symbol and relocation information\n\
698   -g -S -d --strip-debug           Remove all debugging symbols & sections\n\
699      --strip-dwo                   Remove all DWO sections\n\
700      --strip-unneeded              Remove all symbols not needed by relocations\n\
701      --only-keep-debug             Strip everything but the debug information\n\
702   -M  --merge-notes                Remove redundant entries in note sections (default)\n\
703       --no-merge-notes             Do not attempt to remove redundant notes\n\
704   -N --strip-symbol=<name>         Do not copy symbol <name>\n\
705   -K --keep-symbol=<name>          Do not strip symbol <name>\n\
706      --keep-file-symbols           Do not strip file symbol(s)\n\
707   -w --wildcard                    Permit wildcard in symbol comparison\n\
708   -x --discard-all                 Remove all non-global symbols\n\
709   -X --discard-locals              Remove any compiler-generated symbols\n\
710   -v --verbose                     List all object files modified\n\
711   -V --version                     Display this program's version number\n\
712   -h --help                        Display this output\n\
713      --info                        List object formats & architectures supported\n\
714   -o <file>                        Place stripped output into <file>\n\
715 "));
716
717   list_supported_targets (program_name, stream);
718   if (REPORT_BUGS_TO[0] && exit_status == 0)
719     fprintf (stream, _("Report bugs to %s\n"), REPORT_BUGS_TO);
720   exit (exit_status);
721 }
722
723 /* Parse section flags into a flagword, with a fatal error if the
724    string can't be parsed.  */
725
726 static flagword
727 parse_flags (const char *s)
728 {
729   flagword ret;
730   const char *snext;
731   int len;
732
733   ret = SEC_NO_FLAGS;
734
735   do
736     {
737       snext = strchr (s, ',');
738       if (snext == NULL)
739         len = strlen (s);
740       else
741         {
742           len = snext - s;
743           ++snext;
744         }
745
746       if (0) ;
747 #define PARSE_FLAG(fname,fval)                                  \
748       else if (strncasecmp (fname, s, len) == 0) ret |= fval
749       PARSE_FLAG ("alloc", SEC_ALLOC);
750       PARSE_FLAG ("load", SEC_LOAD);
751       PARSE_FLAG ("noload", SEC_NEVER_LOAD);
752       PARSE_FLAG ("readonly", SEC_READONLY);
753       PARSE_FLAG ("debug", SEC_DEBUGGING);
754       PARSE_FLAG ("code", SEC_CODE);
755       PARSE_FLAG ("data", SEC_DATA);
756       PARSE_FLAG ("rom", SEC_ROM);
757       PARSE_FLAG ("share", SEC_COFF_SHARED);
758       PARSE_FLAG ("contents", SEC_HAS_CONTENTS);
759       PARSE_FLAG ("merge", SEC_MERGE);
760       PARSE_FLAG ("strings", SEC_STRINGS);
761 #undef PARSE_FLAG
762       else
763         {
764           char *copy;
765
766           copy = (char *) xmalloc (len + 1);
767           strncpy (copy, s, len);
768           copy[len] = '\0';
769           non_fatal (_("unrecognized section flag `%s'"), copy);
770           fatal (_("supported flags: %s"),
771                  "alloc, load, noload, readonly, debug, code, data, rom, share, contents, merge, strings");
772         }
773
774       s = snext;
775     }
776   while (s != NULL);
777
778   return ret;
779 }
780
781 /* Parse symbol flags into a flagword, with a fatal error if the
782    string can't be parsed.  */
783
784 static flagword
785 parse_symflags (const char *s, char **other)
786 {
787   flagword ret;
788   const char *snext;
789   size_t len;
790
791   ret = BSF_NO_FLAGS;
792
793   do
794     {
795       snext = strchr (s, ',');
796       if (snext == NULL)
797         len = strlen (s);
798       else
799         {
800           len = snext - s;
801           ++snext;
802         }
803
804 #define PARSE_FLAG(fname, fval)                                         \
805       else if (len == sizeof fname - 1                                  \
806                && strncasecmp (fname, s, len) == 0)                     \
807         ret |= fval
808
809 #define PARSE_OTHER(fname, fval)                                        \
810       else if (len >= sizeof fname                                      \
811                && strncasecmp (fname, s, sizeof fname - 1) == 0)        \
812         fval = xstrndup (s + sizeof fname - 1, len - sizeof fname + 1)
813
814       if (0) ;
815       PARSE_FLAG ("local", BSF_LOCAL);
816       PARSE_FLAG ("global", BSF_GLOBAL);
817       PARSE_FLAG ("export", BSF_EXPORT);
818       PARSE_FLAG ("debug", BSF_DEBUGGING);
819       PARSE_FLAG ("function", BSF_FUNCTION);
820       PARSE_FLAG ("weak", BSF_WEAK);
821       PARSE_FLAG ("section", BSF_SECTION_SYM);
822       PARSE_FLAG ("constructor", BSF_CONSTRUCTOR);
823       PARSE_FLAG ("warning", BSF_WARNING);
824       PARSE_FLAG ("indirect", BSF_INDIRECT);
825       PARSE_FLAG ("file", BSF_FILE);
826       PARSE_FLAG ("object", BSF_OBJECT);
827       PARSE_FLAG ("synthetic", BSF_SYNTHETIC);
828       PARSE_FLAG ("indirect-function", BSF_GNU_INDIRECT_FUNCTION | BSF_FUNCTION);
829       PARSE_FLAG ("unique-object", BSF_GNU_UNIQUE | BSF_OBJECT);
830       PARSE_OTHER ("before=", *other);
831
832 #undef PARSE_FLAG
833 #undef PARSE_OTHER
834       else
835         {
836           char *copy;
837
838           copy = (char *) xmalloc (len + 1);
839           strncpy (copy, s, len);
840           copy[len] = '\0';
841           non_fatal (_("unrecognized symbol flag `%s'"), copy);
842           fatal (_("supported flags: %s"),
843                  "local, global, export, debug, function, weak, section, "
844                  "constructor, warning, indirect, file, object, synthetic, "
845                  "indirect-function, unique-object, before=<othersym>");
846         }
847
848       s = snext;
849     }
850   while (s != NULL);
851
852   return ret;
853 }
854
855 /* Find and optionally add an entry in the change_sections list.
856
857    We need to be careful in how we match section names because of the support
858    for wildcard characters.  For example suppose that the user has invoked
859    objcopy like this:
860
861        --set-section-flags .debug_*=debug
862        --set-section-flags .debug_str=readonly,debug
863        --change-section-address .debug_*ranges=0x1000
864
865    With the idea that all debug sections will receive the DEBUG flag, the
866    .debug_str section will also receive the READONLY flag and the
867    .debug_ranges and .debug_aranges sections will have their address set to
868    0x1000.  (This may not make much sense, but it is just an example).
869
870    When adding the section name patterns to the section list we need to make
871    sure that previous entries do not match with the new entry, unless the
872    match is exact.  (In which case we assume that the user is overriding
873    the previous entry with the new context).
874
875    When matching real section names to the section list we make use of the
876    wildcard characters, but we must do so in context.  Eg if we are setting
877    section addresses then we match for .debug_ranges but not for .debug_info.
878
879    Finally, if ADD is false and we do find a match, we mark the section list
880    entry as used.  */
881
882 static struct section_list *
883 find_section_list (const char *name, bfd_boolean add, unsigned int context)
884 {
885   struct section_list *p, *match = NULL;
886
887   /* assert ((context & ((1 << 7) - 1)) != 0); */
888
889   for (p = change_sections; p != NULL; p = p->next)
890     {
891       if (add)
892         {
893           if (strcmp (p->pattern, name) == 0)
894             {
895               /* Check for context conflicts.  */
896               if (((p->context & SECTION_CONTEXT_REMOVE)
897                    && (context & SECTION_CONTEXT_COPY))
898                   || ((context & SECTION_CONTEXT_REMOVE)
899                       && (p->context & SECTION_CONTEXT_COPY)))
900                 fatal (_("error: %s both copied and removed"), name);
901
902               if (((p->context & SECTION_CONTEXT_SET_VMA)
903                   && (context & SECTION_CONTEXT_ALTER_VMA))
904                   || ((context & SECTION_CONTEXT_SET_VMA)
905                       && (context & SECTION_CONTEXT_ALTER_VMA)))
906                 fatal (_("error: %s both sets and alters VMA"), name);
907
908               if (((p->context & SECTION_CONTEXT_SET_LMA)
909                   && (context & SECTION_CONTEXT_ALTER_LMA))
910                   || ((context & SECTION_CONTEXT_SET_LMA)
911                       && (context & SECTION_CONTEXT_ALTER_LMA)))
912                 fatal (_("error: %s both sets and alters LMA"), name);
913
914               /* Extend the context.  */
915               p->context |= context;
916               return p;
917             }
918         }
919       /* If we are not adding a new name/pattern then
920          only check for a match if the context applies.  */
921       else if (p->context & context)
922         {
923           /* We could check for the presence of wildchar characters
924              first and choose between calling strcmp and fnmatch,
925              but is that really worth it ?  */
926           if (p->pattern [0] == '!')
927             {
928               if (fnmatch (p->pattern + 1, name, 0) == 0)
929                 {
930                   p->used = TRUE;
931                   return NULL;
932                 }
933             }
934           else
935             {
936               if (fnmatch (p->pattern, name, 0) == 0)
937                 {
938                   if (match == NULL)
939                     match = p;
940                 }
941             }
942         }
943     }
944
945   if (! add)
946     {
947       if (match != NULL)
948         match->used = TRUE;
949       return match;
950     }
951
952   p = (struct section_list *) xmalloc (sizeof (struct section_list));
953   p->pattern = name;
954   p->used = FALSE;
955   p->context = context;
956   p->vma_val = 0;
957   p->lma_val = 0;
958   p->flags = 0;
959   p->next = change_sections;
960   change_sections = p;
961
962   return p;
963 }
964
965 /* S1 is the entry node already in the table, S2 is the key node.  */
966
967 static int
968 eq_string_redefnode (const void *s1, const void *s2)
969 {
970   struct redefine_node *node1 = (struct redefine_node *) s1;
971   struct redefine_node *node2 = (struct redefine_node *) s2;
972   return !strcmp ((const char *) node1->source, (const char *) node2->source);
973 }
974
975 /* P is redefine node.  Hash value is generated from its "source" filed.  */
976
977 static hashval_t
978 htab_hash_redefnode (const void *p)
979 {
980   struct redefine_node *redefnode = (struct redefine_node *) p;
981   return htab_hash_string (redefnode->source);
982 }
983
984 /* Create hashtab used for redefine node.  */
985
986 static htab_t
987 create_symbol2redef_htab (void)
988 {
989   return htab_create_alloc (16, htab_hash_redefnode, eq_string_redefnode, NULL,
990                             xcalloc, free);
991 }
992
993 /* There is htab_hash_string but no htab_eq_string. Makes sense.  */
994
995 static int
996 eq_string (const void *s1, const void *s2)
997 {
998   return strcmp ((const char *) s1, (const char *) s2) == 0;
999 }
1000
1001 static htab_t
1002 create_symbol_htab (void)
1003 {
1004   return htab_create_alloc (16, htab_hash_string, eq_string, NULL, xcalloc, free);
1005 }
1006
1007 static void
1008 create_symbol_htabs (void)
1009 {
1010   strip_specific_htab = create_symbol_htab ();
1011   strip_unneeded_htab = create_symbol_htab ();
1012   keep_specific_htab = create_symbol_htab ();
1013   localize_specific_htab = create_symbol_htab ();
1014   globalize_specific_htab = create_symbol_htab ();
1015   keepglobal_specific_htab = create_symbol_htab ();
1016   weaken_specific_htab = create_symbol_htab ();
1017   redefine_specific_htab = create_symbol2redef_htab ();
1018   /* As there is no bidirectional hash table in libiberty, need a reverse table
1019      to check duplicated target string.  */
1020   redefine_specific_reverse_htab = create_symbol_htab ();
1021 }
1022
1023 /* Add a symbol to strip_specific_list.  */
1024
1025 static void
1026 add_specific_symbol (const char *name, htab_t htab)
1027 {
1028   *htab_find_slot (htab, name, INSERT) = (char *) name;
1029 }
1030
1031 /* Like add_specific_symbol, but the element type is void *.  */
1032
1033 static void
1034 add_specific_symbol_node (const void *node, htab_t htab)
1035 {
1036   *htab_find_slot (htab, node, INSERT) = (void *) node;
1037 }
1038
1039 /* Add symbols listed in `filename' to strip_specific_list.  */
1040
1041 #define IS_WHITESPACE(c)      ((c) == ' ' || (c) == '\t')
1042 #define IS_LINE_TERMINATOR(c) ((c) == '\n' || (c) == '\r' || (c) == '\0')
1043
1044 static void
1045 add_specific_symbols (const char *filename, htab_t htab, char **buffer_p)
1046 {
1047   off_t  size;
1048   FILE * f;
1049   char * line;
1050   char * buffer;
1051   unsigned int line_count;
1052
1053   size = get_file_size (filename);
1054   if (size == 0)
1055     {
1056       status = 1;
1057       return;
1058     }
1059
1060   buffer = (char *) xmalloc (size + 2);
1061   f = fopen (filename, FOPEN_RT);
1062   if (f == NULL)
1063     fatal (_("cannot open '%s': %s"), filename, strerror (errno));
1064
1065   if (fread (buffer, 1, size, f) == 0 || ferror (f))
1066     fatal (_("%s: fread failed"), filename);
1067
1068   fclose (f);
1069   buffer [size] = '\n';
1070   buffer [size + 1] = '\0';
1071
1072   line_count = 1;
1073
1074   for (line = buffer; * line != '\0'; line ++)
1075     {
1076       char * eol;
1077       char * name;
1078       char * name_end;
1079       int finished = FALSE;
1080
1081       for (eol = line;; eol ++)
1082         {
1083           switch (* eol)
1084             {
1085             case '\n':
1086               * eol = '\0';
1087               /* Cope with \n\r.  */
1088               if (eol[1] == '\r')
1089                 ++ eol;
1090               finished = TRUE;
1091               break;
1092
1093             case '\r':
1094               * eol = '\0';
1095               /* Cope with \r\n.  */
1096               if (eol[1] == '\n')
1097                 ++ eol;
1098               finished = TRUE;
1099               break;
1100
1101             case 0:
1102               finished = TRUE;
1103               break;
1104
1105             case '#':
1106               /* Line comment, Terminate the line here, in case a
1107                  name is present and then allow the rest of the
1108                  loop to find the real end of the line.  */
1109               * eol = '\0';
1110               break;
1111
1112             default:
1113               break;
1114             }
1115
1116           if (finished)
1117             break;
1118         }
1119
1120       /* A name may now exist somewhere between 'line' and 'eol'.
1121          Strip off leading whitespace and trailing whitespace,
1122          then add it to the list.  */
1123       for (name = line; IS_WHITESPACE (* name); name ++)
1124         ;
1125       for (name_end = name;
1126            (! IS_WHITESPACE (* name_end))
1127            && (! IS_LINE_TERMINATOR (* name_end));
1128            name_end ++)
1129         ;
1130
1131       if (! IS_LINE_TERMINATOR (* name_end))
1132         {
1133           char * extra;
1134
1135           for (extra = name_end + 1; IS_WHITESPACE (* extra); extra ++)
1136             ;
1137
1138           if (! IS_LINE_TERMINATOR (* extra))
1139             non_fatal (_("%s:%d: Ignoring rubbish found on this line"),
1140                        filename, line_count);
1141         }
1142
1143       * name_end = '\0';
1144
1145       if (name_end > name)
1146         add_specific_symbol (name, htab);
1147
1148       /* Advance line pointer to end of line.  The 'eol ++' in the for
1149          loop above will then advance us to the start of the next line.  */
1150       line = eol;
1151       line_count ++;
1152     }
1153
1154   /* Do not free the buffer.  Parts of it will have been referenced
1155      in the calls to add_specific_symbol.  */
1156   *buffer_p = buffer;
1157 }
1158
1159 /* See whether a symbol should be stripped or kept
1160    based on strip_specific_list and keep_symbols.  */
1161
1162 static int
1163 is_specified_symbol_predicate (void **slot, void *data)
1164 {
1165   struct is_specified_symbol_predicate_data *d =
1166       (struct is_specified_symbol_predicate_data *) data;
1167   const char *slot_name = (char *) *slot;
1168
1169   if (*slot_name != '!')
1170     {
1171       if (! fnmatch (slot_name, d->name, 0))
1172         {
1173           d->found = TRUE;
1174           /* Continue traversal, there might be a non-match rule.  */
1175           return 1;
1176         }
1177     }
1178   else
1179     {
1180       if (! fnmatch (slot_name + 1, d->name, 0))
1181         {
1182           d->found = FALSE;
1183           /* Stop traversal.  */
1184           return 0;
1185         }
1186     }
1187
1188   /* Continue traversal.  */
1189   return 1;
1190 }
1191
1192 static bfd_boolean
1193 is_specified_symbol (const char *name, htab_t htab)
1194 {
1195   if (wildcard)
1196     {
1197       struct is_specified_symbol_predicate_data data;
1198
1199       data.name = name;
1200       data.found = FALSE;
1201
1202       htab_traverse (htab, is_specified_symbol_predicate, &data);
1203
1204       return data.found;
1205     }
1206
1207   return htab_find (htab, name) != NULL;
1208 }
1209
1210 /* Return a pointer to the symbol used as a signature for GROUP.  */
1211
1212 static asymbol *
1213 group_signature (asection *group)
1214 {
1215   bfd *abfd = group->owner;
1216   Elf_Internal_Shdr *ghdr;
1217
1218   /* PR 20089: An earlier error may have prevented us from loading the symbol table.  */
1219   if (isympp == NULL)
1220     return NULL;
1221
1222   if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
1223     return NULL;
1224
1225   ghdr = &elf_section_data (group)->this_hdr;
1226   if (ghdr->sh_link == elf_onesymtab (abfd))
1227     {
1228       const struct elf_backend_data *bed = get_elf_backend_data (abfd);
1229       Elf_Internal_Shdr *symhdr = &elf_symtab_hdr (abfd);
1230
1231       if (ghdr->sh_info > 0
1232           && ghdr->sh_info < symhdr->sh_size / bed->s->sizeof_sym)
1233         return isympp[ghdr->sh_info - 1];
1234     }
1235   return NULL;
1236 }
1237
1238 /* Return TRUE if the section is a DWO section.  */
1239
1240 static bfd_boolean
1241 is_dwo_section (bfd *abfd ATTRIBUTE_UNUSED, asection *sec)
1242 {
1243   const char *name = bfd_get_section_name (abfd, sec);
1244   int len = strlen (name);
1245
1246   return strncmp (name + len - 4, ".dwo", 4) == 0;
1247 }
1248
1249 /* Return TRUE if section SEC is in the update list.  */
1250
1251 static bfd_boolean
1252 is_update_section (bfd *abfd ATTRIBUTE_UNUSED, asection *sec)
1253 {
1254   if (update_sections != NULL)
1255     {
1256       struct section_add *pupdate;
1257
1258       for (pupdate = update_sections;
1259            pupdate != NULL;
1260            pupdate = pupdate->next)
1261         {
1262           if (strcmp (sec->name, pupdate->name) == 0)
1263             return TRUE;
1264         }
1265     }
1266
1267   return FALSE;
1268 }
1269
1270 static bfd_boolean
1271 is_merged_note_section (bfd * abfd, asection * sec)
1272 {
1273   if (merge_notes
1274       && bfd_get_flavour (abfd) == bfd_target_elf_flavour
1275       && elf_section_data (sec)->this_hdr.sh_type == SHT_NOTE
1276       /* FIXME: We currently only support merging GNU_BUILD_NOTEs.
1277          We should add support for more note types.  */
1278       && ((elf_section_data (sec)->this_hdr.sh_flags & SHF_GNU_BUILD_NOTE) != 0
1279           /* Old versions of GAS (prior to 2.27) could not set the section
1280              flags to OS-specific values, so we also accept sections with the
1281              expected name.  */
1282           || (strcmp (sec->name, GNU_BUILD_ATTRS_SECTION_NAME) == 0)))
1283     return TRUE;
1284
1285   return FALSE;
1286 }
1287
1288 /* See if a non-group section is being removed.  */
1289
1290 static bfd_boolean
1291 is_strip_section_1 (bfd *abfd ATTRIBUTE_UNUSED, asection *sec)
1292 {
1293   if (sections_removed || sections_copied)
1294     {
1295       struct section_list *p;
1296       struct section_list *q;
1297
1298       p = find_section_list (bfd_get_section_name (abfd, sec), FALSE,
1299                              SECTION_CONTEXT_REMOVE);
1300       q = find_section_list (bfd_get_section_name (abfd, sec), FALSE,
1301                              SECTION_CONTEXT_COPY);
1302
1303       if (p && q)
1304         fatal (_("error: section %s matches both remove and copy options"),
1305                bfd_get_section_name (abfd, sec));
1306       if (p && is_update_section (abfd, sec))
1307         fatal (_("error: section %s matches both update and remove options"),
1308                bfd_get_section_name (abfd, sec));
1309
1310       if (p != NULL)
1311         return TRUE;
1312       if (sections_copied && q == NULL)
1313         return TRUE;
1314     }
1315
1316   if ((bfd_get_section_flags (abfd, sec) & SEC_DEBUGGING) != 0)
1317     {
1318       if (strip_symbols == STRIP_DEBUG
1319           || strip_symbols == STRIP_UNNEEDED
1320           || strip_symbols == STRIP_ALL
1321           || discard_locals == LOCALS_ALL
1322           || convert_debugging)
1323         {
1324           /* By default we don't want to strip .reloc section.
1325              This section has for pe-coff special meaning.   See
1326              pe-dll.c file in ld, and peXXigen.c in bfd for details.  */
1327           if (strcmp (bfd_get_section_name (abfd, sec), ".reloc") != 0)
1328             return TRUE;
1329         }
1330
1331       if (strip_symbols == STRIP_DWO)
1332         return is_dwo_section (abfd, sec);
1333
1334       if (strip_symbols == STRIP_NONDEBUG)
1335         return FALSE;
1336     }
1337
1338   if (strip_symbols == STRIP_NONDWO)
1339     return !is_dwo_section (abfd, sec);
1340
1341   return FALSE;
1342 }
1343
1344 /* See if a section is being removed.  */
1345
1346 static bfd_boolean
1347 is_strip_section (bfd *abfd ATTRIBUTE_UNUSED, asection *sec)
1348 {
1349   if (is_strip_section_1 (abfd, sec))
1350     return TRUE;
1351
1352   if ((bfd_get_section_flags (abfd, sec) & SEC_GROUP) != 0)
1353     {
1354       asymbol *gsym;
1355       const char *gname;
1356       asection *elt, *first;
1357
1358       gsym = group_signature (sec);
1359       /* Strip groups without a valid signature.  */
1360       if (gsym == NULL)
1361         return TRUE;
1362
1363       /* PR binutils/3181
1364          If we are going to strip the group signature symbol, then
1365          strip the group section too.  */
1366       gname = gsym->name;
1367       if ((strip_symbols == STRIP_ALL
1368            && !is_specified_symbol (gname, keep_specific_htab))
1369           || is_specified_symbol (gname, strip_specific_htab))
1370         return TRUE;
1371
1372       /* Remove the group section if all members are removed.  */
1373       first = elt = elf_next_in_group (sec);
1374       while (elt != NULL)
1375         {
1376           if (!is_strip_section_1 (abfd, elt))
1377             return FALSE;
1378           elt = elf_next_in_group (elt);
1379           if (elt == first)
1380             break;
1381         }
1382
1383       return TRUE;
1384     }
1385
1386   return FALSE;
1387 }
1388
1389 static bfd_boolean
1390 is_nondebug_keep_contents_section (bfd *ibfd, asection *isection)
1391 {
1392   /* Always keep ELF note sections.  */
1393   if (ibfd->xvec->flavour == bfd_target_elf_flavour)
1394     return (elf_section_type (isection) == SHT_NOTE);
1395
1396   /* Always keep the .buildid section for PE/COFF.
1397
1398      Strictly, this should be written "always keep the section storing the debug
1399      directory", but that may be the .text section for objects produced by some
1400      tools, which it is not sensible to keep.  */
1401   if (ibfd->xvec->flavour == bfd_target_coff_flavour)
1402     return (strcmp (bfd_get_section_name (ibfd, isection), ".buildid") == 0);
1403
1404   return FALSE;
1405 }
1406
1407 /* Return true if SYM is a hidden symbol.  */
1408
1409 static bfd_boolean
1410 is_hidden_symbol (asymbol *sym)
1411 {
1412   elf_symbol_type *elf_sym;
1413
1414   elf_sym = elf_symbol_from (sym->the_bfd, sym);
1415   if (elf_sym != NULL)
1416     switch (ELF_ST_VISIBILITY (elf_sym->internal_elf_sym.st_other))
1417       {
1418       case STV_HIDDEN:
1419       case STV_INTERNAL:
1420         return TRUE;
1421       }
1422   return FALSE;
1423 }
1424
1425 static bfd_boolean
1426 need_sym_before (struct addsym_node **node, const char *sym)
1427 {
1428   int count;
1429   struct addsym_node *ptr = add_sym_list;
1430
1431   /* 'othersym' symbols are at the front of the list.  */
1432   for (count = 0; count < add_symbols; count++)
1433     {
1434       if (!ptr->othersym)
1435         break;
1436       else if (strcmp (ptr->othersym, sym) == 0)
1437         {
1438           free (ptr->othersym);
1439           ptr->othersym = ""; /* Empty name is hopefully never a valid symbol name.  */
1440           *node = ptr;
1441           return TRUE;
1442         }
1443       ptr = ptr->next;
1444     }
1445   return FALSE;
1446 }
1447
1448 static asymbol *
1449 create_new_symbol (struct addsym_node *ptr, bfd *obfd)
1450 {
1451   asymbol *sym = bfd_make_empty_symbol (obfd);
1452
1453   bfd_asymbol_name (sym) = ptr->symdef;
1454   sym->value = ptr->symval;
1455   sym->flags = ptr->flags;
1456   if (ptr->section)
1457     {
1458       asection *sec = bfd_get_section_by_name (obfd, ptr->section);
1459       if (!sec)
1460         fatal (_("Section %s not found"), ptr->section);
1461       sym->section = sec;
1462     }
1463   else
1464     sym->section = bfd_abs_section_ptr;
1465   return sym;
1466 }
1467
1468 /* Choose which symbol entries to copy; put the result in OSYMS.
1469    We don't copy in place, because that confuses the relocs.
1470    Return the number of symbols to print.  */
1471
1472 static unsigned int
1473 filter_symbols (bfd *abfd, bfd *obfd, asymbol **osyms,
1474                 asymbol **isyms, long symcount)
1475 {
1476   asymbol **from = isyms, **to = osyms;
1477   long src_count = 0, dst_count = 0;
1478   int relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
1479
1480   for (; src_count < symcount; src_count++)
1481     {
1482       asymbol *sym = from[src_count];
1483       flagword flags = sym->flags;
1484       char *name = (char *) bfd_asymbol_name (sym);
1485       bfd_boolean keep;
1486       bfd_boolean used_in_reloc = FALSE;
1487       bfd_boolean undefined;
1488       bfd_boolean rem_leading_char;
1489       bfd_boolean add_leading_char;
1490
1491       undefined = bfd_is_und_section (bfd_get_section (sym));
1492
1493       if (add_sym_list)
1494         {
1495           struct addsym_node *ptr;
1496
1497           if (need_sym_before (&ptr, name))
1498             to[dst_count++] = create_new_symbol (ptr, obfd);
1499         }
1500
1501       if (htab_elements (redefine_specific_htab) || section_rename_list)
1502         {
1503           char *new_name;
1504
1505           new_name = (char *) lookup_sym_redefinition (name);
1506           if (new_name == name
1507               && (flags & BSF_SECTION_SYM) != 0)
1508             new_name = (char *) find_section_rename (name, NULL);
1509           bfd_asymbol_name (sym) = new_name;
1510           name = new_name;
1511         }
1512
1513       /* Check if we will remove the current leading character.  */
1514       rem_leading_char =
1515         (name[0] == bfd_get_symbol_leading_char (abfd))
1516         && (change_leading_char
1517             || (remove_leading_char
1518                 && ((flags & (BSF_GLOBAL | BSF_WEAK)) != 0
1519                     || undefined
1520                     || bfd_is_com_section (bfd_get_section (sym)))));
1521
1522       /* Check if we will add a new leading character.  */
1523       add_leading_char =
1524         change_leading_char
1525         && (bfd_get_symbol_leading_char (obfd) != '\0')
1526         && (bfd_get_symbol_leading_char (abfd) == '\0'
1527             || (name[0] == bfd_get_symbol_leading_char (abfd)));
1528
1529       /* Short circuit for change_leading_char if we can do it in-place.  */
1530       if (rem_leading_char && add_leading_char && !prefix_symbols_string)
1531         {
1532           name[0] = bfd_get_symbol_leading_char (obfd);
1533           bfd_asymbol_name (sym) = name;
1534           rem_leading_char = FALSE;
1535           add_leading_char = FALSE;
1536         }
1537
1538       /* Remove leading char.  */
1539       if (rem_leading_char)
1540         bfd_asymbol_name (sym) = ++name;
1541
1542       /* Add new leading char and/or prefix.  */
1543       if (add_leading_char || prefix_symbols_string)
1544         {
1545           char *n, *ptr;
1546
1547           ptr = n = (char *) xmalloc (1 + strlen (prefix_symbols_string)
1548                                       + strlen (name) + 1);
1549           if (add_leading_char)
1550             *ptr++ = bfd_get_symbol_leading_char (obfd);
1551
1552           if (prefix_symbols_string)
1553             {
1554               strcpy (ptr, prefix_symbols_string);
1555               ptr += strlen (prefix_symbols_string);
1556             }
1557
1558           strcpy (ptr, name);
1559           bfd_asymbol_name (sym) = n;
1560           name = n;
1561         }
1562
1563       if (strip_symbols == STRIP_ALL)
1564         keep = FALSE;
1565       else if ((flags & BSF_KEEP) != 0          /* Used in relocation.  */
1566                || ((flags & BSF_SECTION_SYM) != 0
1567                    && ((*bfd_get_section (sym)->symbol_ptr_ptr)->flags
1568                        & BSF_KEEP) != 0))
1569         {
1570           keep = TRUE;
1571           used_in_reloc = TRUE;
1572         }
1573       else if (relocatable                      /* Relocatable file.  */
1574                && ((flags & (BSF_GLOBAL | BSF_WEAK)) != 0
1575                    || bfd_is_com_section (bfd_get_section (sym))))
1576         keep = TRUE;
1577       else if (bfd_decode_symclass (sym) == 'I')
1578         /* Global symbols in $idata sections need to be retained
1579            even if relocatable is FALSE.  External users of the
1580            library containing the $idata section may reference these
1581            symbols.  */
1582         keep = TRUE;
1583       else if ((flags & BSF_GLOBAL) != 0        /* Global symbol.  */
1584                || (flags & BSF_WEAK) != 0
1585                || undefined
1586                || bfd_is_com_section (bfd_get_section (sym)))
1587         keep = strip_symbols != STRIP_UNNEEDED;
1588       else if ((flags & BSF_DEBUGGING) != 0)    /* Debugging symbol.  */
1589         keep = (strip_symbols != STRIP_DEBUG
1590                 && strip_symbols != STRIP_UNNEEDED
1591                 && ! convert_debugging);
1592       else if (bfd_coff_get_comdat_section (abfd, bfd_get_section (sym)))
1593         /* COMDAT sections store special information in local
1594            symbols, so we cannot risk stripping any of them.  */
1595         keep = TRUE;
1596       else                      /* Local symbol.  */
1597         keep = (strip_symbols != STRIP_UNNEEDED
1598                 && (discard_locals != LOCALS_ALL
1599                     && (discard_locals != LOCALS_START_L
1600                         || ! bfd_is_local_label (abfd, sym))));
1601
1602       if (keep && is_specified_symbol (name, strip_specific_htab))
1603         {
1604           /* There are multiple ways to set 'keep' above, but if it
1605              was the relocatable symbol case, then that's an error.  */
1606           if (used_in_reloc)
1607             {
1608               non_fatal (_("not stripping symbol `%s' because it is named in a relocation"), name);
1609               status = 1;
1610             }
1611           else
1612             keep = FALSE;
1613         }
1614
1615       if (keep
1616           && !(flags & BSF_KEEP)
1617           && is_specified_symbol (name, strip_unneeded_htab))
1618         keep = FALSE;
1619
1620       if (!keep
1621           && ((keep_file_symbols && (flags & BSF_FILE))
1622               || is_specified_symbol (name, keep_specific_htab)))
1623         keep = TRUE;
1624
1625       if (keep && is_strip_section (abfd, bfd_get_section (sym)))
1626         keep = FALSE;
1627
1628       if (keep)
1629         {
1630           if ((flags & BSF_GLOBAL) != 0
1631               && (weaken || is_specified_symbol (name, weaken_specific_htab)))
1632             {
1633               sym->flags &= ~ BSF_GLOBAL;
1634               sym->flags |= BSF_WEAK;
1635             }
1636
1637           if (!undefined
1638               && (flags & (BSF_GLOBAL | BSF_WEAK))
1639               && (is_specified_symbol (name, localize_specific_htab)
1640                   || (htab_elements (keepglobal_specific_htab) != 0
1641                       && ! is_specified_symbol (name, keepglobal_specific_htab))
1642                   || (localize_hidden && is_hidden_symbol (sym))))
1643             {
1644               sym->flags &= ~ (BSF_GLOBAL | BSF_WEAK);
1645               sym->flags |= BSF_LOCAL;
1646             }
1647
1648           if (!undefined
1649               && (flags & BSF_LOCAL)
1650               && is_specified_symbol (name, globalize_specific_htab))
1651             {
1652               sym->flags &= ~ BSF_LOCAL;
1653               sym->flags |= BSF_GLOBAL;
1654             }
1655
1656           to[dst_count++] = sym;
1657         }
1658     }
1659   if (add_sym_list)
1660     {
1661       struct addsym_node *ptr = add_sym_list;
1662
1663       for (src_count = 0; src_count < add_symbols; src_count++)
1664         {
1665           if (ptr->othersym)
1666             {
1667               if (strcmp (ptr->othersym, ""))
1668                 fatal (_("'before=%s' not found"), ptr->othersym);
1669             }
1670           else
1671             to[dst_count++] = create_new_symbol (ptr, obfd);
1672
1673           ptr = ptr->next;
1674         }
1675     }
1676
1677   to[dst_count] = NULL;
1678
1679   return dst_count;
1680 }
1681
1682 /* Find the redefined name of symbol SOURCE.  */
1683
1684 static const char *
1685 lookup_sym_redefinition (const char *source)
1686 {
1687   struct redefine_node key_node = {(char *) source, NULL};
1688   struct redefine_node *redef_node
1689     = (struct redefine_node *) htab_find (redefine_specific_htab, &key_node);
1690
1691   return redef_node == NULL ? source : redef_node->target;
1692 }
1693
1694 /* Insert a node into symbol redefine hash tabel.  */
1695
1696 static void
1697 add_redefine_and_check (const char *cause, const char *source,
1698                         const char *target)
1699 {
1700   struct redefine_node *new_node
1701     = (struct redefine_node *) xmalloc (sizeof (struct redefine_node));
1702
1703   new_node->source = strdup (source);
1704   new_node->target = strdup (target);
1705
1706   if (htab_find (redefine_specific_htab, new_node) != HTAB_EMPTY_ENTRY)
1707     fatal (_("%s: Multiple redefinition of symbol \"%s\""),
1708            cause, source);
1709
1710   if (htab_find (redefine_specific_reverse_htab, target) != HTAB_EMPTY_ENTRY)
1711     fatal (_("%s: Symbol \"%s\" is target of more than one redefinition"),
1712            cause, target);
1713
1714   /* Insert the NEW_NODE into hash table for quick search.  */
1715   add_specific_symbol_node (new_node, redefine_specific_htab);
1716
1717   /* Insert the target string into the reverse hash table, this is needed for
1718      duplicated target string check.  */
1719   add_specific_symbol (new_node->target, redefine_specific_reverse_htab);
1720
1721 }
1722
1723 /* Handle the --redefine-syms option.  Read lines containing "old new"
1724    from the file, and add them to the symbol redefine list.  */
1725
1726 static void
1727 add_redefine_syms_file (const char *filename)
1728 {
1729   FILE *file;
1730   char *buf;
1731   size_t bufsize;
1732   size_t len;
1733   size_t outsym_off;
1734   int c, lineno;
1735
1736   file = fopen (filename, "r");
1737   if (file == NULL)
1738     fatal (_("couldn't open symbol redefinition file %s (error: %s)"),
1739            filename, strerror (errno));
1740
1741   bufsize = 100;
1742   buf = (char *) xmalloc (bufsize + 1 /* For the terminating NUL.  */);
1743
1744   lineno = 1;
1745   c = getc (file);
1746   len = 0;
1747   outsym_off = 0;
1748   while (c != EOF)
1749     {
1750       /* Collect the input symbol name.  */
1751       while (! IS_WHITESPACE (c) && ! IS_LINE_TERMINATOR (c) && c != EOF)
1752         {
1753           if (c == '#')
1754             goto comment;
1755           buf[len++] = c;
1756           if (len >= bufsize)
1757             {
1758               bufsize *= 2;
1759               buf = (char *) xrealloc (buf, bufsize + 1);
1760             }
1761           c = getc (file);
1762         }
1763       buf[len++] = '\0';
1764       if (c == EOF)
1765         break;
1766
1767       /* Eat white space between the symbol names.  */
1768       while (IS_WHITESPACE (c))
1769         c = getc (file);
1770       if (c == '#' || IS_LINE_TERMINATOR (c))
1771         goto comment;
1772       if (c == EOF)
1773         break;
1774
1775       /* Collect the output symbol name.  */
1776       outsym_off = len;
1777       while (! IS_WHITESPACE (c) && ! IS_LINE_TERMINATOR (c) && c != EOF)
1778         {
1779           if (c == '#')
1780             goto comment;
1781           buf[len++] = c;
1782           if (len >= bufsize)
1783             {
1784               bufsize *= 2;
1785               buf = (char *) xrealloc (buf, bufsize + 1);
1786             }
1787           c = getc (file);
1788         }
1789       buf[len++] = '\0';
1790       if (c == EOF)
1791         break;
1792
1793       /* Eat white space at end of line.  */
1794       while (! IS_LINE_TERMINATOR(c) && c != EOF && IS_WHITESPACE (c))
1795         c = getc (file);
1796       if (c == '#')
1797         goto comment;
1798       /* Handle \r\n.  */
1799       if ((c == '\r' && (c = getc (file)) == '\n')
1800           || c == '\n' || c == EOF)
1801         {
1802         end_of_line:
1803           /* Append the redefinition to the list.  */
1804           if (buf[0] != '\0')
1805             add_redefine_and_check (filename, &buf[0], &buf[outsym_off]);
1806
1807           lineno++;
1808           len = 0;
1809           outsym_off = 0;
1810           if (c == EOF)
1811             break;
1812           c = getc (file);
1813           continue;
1814         }
1815       else
1816         fatal (_("%s:%d: garbage found at end of line"), filename, lineno);
1817     comment:
1818       if (len != 0 && (outsym_off == 0 || outsym_off == len))
1819         fatal (_("%s:%d: missing new symbol name"), filename, lineno);
1820       buf[len++] = '\0';
1821
1822       /* Eat the rest of the line and finish it.  */
1823       while (c != '\n' && c != EOF)
1824         c = getc (file);
1825       goto end_of_line;
1826     }
1827
1828   if (len != 0)
1829     fatal (_("%s:%d: premature end of file"), filename, lineno);
1830
1831   free (buf);
1832   fclose (file);
1833 }
1834
1835 /* Copy unknown object file IBFD onto OBFD.
1836    Returns TRUE upon success, FALSE otherwise.  */
1837
1838 static bfd_boolean
1839 copy_unknown_object (bfd *ibfd, bfd *obfd)
1840 {
1841   char *cbuf;
1842   int tocopy;
1843   long ncopied;
1844   long size;
1845   struct stat buf;
1846
1847   if (bfd_stat_arch_elt (ibfd, &buf) != 0)
1848     {
1849       bfd_nonfatal_message (NULL, ibfd, NULL, NULL);
1850       return FALSE;
1851     }
1852
1853   size = buf.st_size;
1854   if (size < 0)
1855     {
1856       non_fatal (_("stat returns negative size for `%s'"),
1857                  bfd_get_archive_filename (ibfd));
1858       return FALSE;
1859     }
1860
1861   if (bfd_seek (ibfd, (file_ptr) 0, SEEK_SET) != 0)
1862     {
1863       bfd_nonfatal (bfd_get_archive_filename (ibfd));
1864       return FALSE;
1865     }
1866
1867   if (verbose)
1868     printf (_("copy from `%s' [unknown] to `%s' [unknown]\n"),
1869             bfd_get_archive_filename (ibfd), bfd_get_filename (obfd));
1870
1871   cbuf = (char *) xmalloc (BUFSIZE);
1872   ncopied = 0;
1873   while (ncopied < size)
1874     {
1875       tocopy = size - ncopied;
1876       if (tocopy > BUFSIZE)
1877         tocopy = BUFSIZE;
1878
1879       if (bfd_bread (cbuf, (bfd_size_type) tocopy, ibfd)
1880           != (bfd_size_type) tocopy)
1881         {
1882           bfd_nonfatal_message (NULL, ibfd, NULL, NULL);
1883           free (cbuf);
1884           return FALSE;
1885         }
1886
1887       if (bfd_bwrite (cbuf, (bfd_size_type) tocopy, obfd)
1888           != (bfd_size_type) tocopy)
1889         {
1890           bfd_nonfatal_message (NULL, obfd, NULL, NULL);
1891           free (cbuf);
1892           return FALSE;
1893         }
1894
1895       ncopied += tocopy;
1896     }
1897
1898   /* We should at least to be able to read it back when copying an
1899      unknown object in an archive.  */
1900   chmod (bfd_get_filename (obfd), buf.st_mode | S_IRUSR);
1901   free (cbuf);
1902   return TRUE;
1903 }
1904
1905 /* Returns the number of bytes needed to store VAL.  */
1906
1907 static inline unsigned int
1908 num_bytes (unsigned long val)
1909 {
1910   unsigned int count = 0;
1911
1912   /* FIXME: There must be a faster way to do this.  */
1913   while (val)
1914     {
1915       count ++;
1916       val >>= 8;
1917     }
1918   return count;
1919 }
1920
1921 typedef struct objcopy_internal_note
1922 {
1923   Elf_Internal_Note  note;
1924   bfd_vma            start;
1925   bfd_vma            end;
1926   bfd_boolean        modified;
1927 } objcopy_internal_note;
1928   
1929 /* Returns TRUE if a gap does, or could, exist between the address range
1930    covered by PNOTE1 and PNOTE2.  */
1931
1932 static bfd_boolean
1933 gap_exists (objcopy_internal_note * pnote1,
1934             objcopy_internal_note * pnote2)
1935 {
1936   /* Without range end notes, we assume that a gap might exist.  */
1937   if (pnote1->end == 0 || pnote2->end == 0)
1938     return TRUE;
1939
1940   /* FIXME: Alignment of 16 bytes taken from x86_64 binaries.
1941      Really we should extract the alignment of the section covered by the notes.  */
1942   return BFD_ALIGN (pnote1->end, 16) < pnote2->start;
1943 }
1944
1945 static bfd_boolean
1946 is_open_note (objcopy_internal_note * pnote)
1947 {
1948   return (pnote->note.type == NT_GNU_BUILD_ATTRIBUTE_OPEN);
1949 }
1950
1951 static bfd_boolean
1952 is_func_note (objcopy_internal_note * pnote)
1953 {
1954   return (pnote->note.type == NT_GNU_BUILD_ATTRIBUTE_FUNC);
1955 }
1956
1957 static bfd_boolean
1958 is_64bit (bfd * abfd)
1959 {
1960   /* Should never happen, but let's be paranoid.  */
1961   if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
1962     return FALSE;
1963
1964   return elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64;
1965 }
1966
1967 /* Merge the notes on SEC, removing redundant entries.
1968    Returns the new, smaller size of the section upon success.  */
1969
1970 static bfd_size_type
1971 merge_gnu_build_notes (bfd * abfd, asection * sec, bfd_size_type size, bfd_byte * contents)
1972 {
1973   objcopy_internal_note *  pnotes_end;
1974   objcopy_internal_note *  pnotes = NULL;
1975   objcopy_internal_note *  pnote;
1976   bfd_size_type       remain = size;
1977   unsigned            version_1_seen = 0;
1978   unsigned            version_2_seen = 0;
1979   unsigned            version_3_seen = 0;
1980   bfd_boolean         duplicate_found = FALSE;
1981   const char *        err = NULL;
1982   bfd_byte *          in = contents;
1983   int                 attribute_type_byte;
1984   int                 val_start;
1985   unsigned long       previous_func_start = 0;
1986   unsigned long       previous_open_start = 0;
1987   unsigned long       previous_func_end = 0;
1988   unsigned long       previous_open_end = 0;
1989   long                relsize;
1990
1991
1992   relsize = bfd_get_reloc_upper_bound (abfd, sec);
1993   if (relsize > 0)
1994     {
1995       arelent **  relpp;
1996       long        relcount;
1997
1998       /* If there are relocs associated with this section then we
1999          cannot safely merge it.  */
2000       relpp = (arelent **) xmalloc (relsize);
2001       relcount = bfd_canonicalize_reloc (abfd, sec, relpp, isympp);
2002       free (relpp);
2003       if (relcount != 0)
2004         goto done;
2005     }
2006   
2007   /* Make a copy of the notes and convert to our internal format.
2008      Minimum size of a note is 12 bytes.  */
2009   pnote = pnotes = (objcopy_internal_note *) xcalloc ((size / 12), sizeof (* pnote));
2010   while (remain >= 12)
2011     {
2012       bfd_vma start, end;
2013
2014       pnote->note.namesz = (bfd_get_32 (abfd, in    ) + 3) & ~3;
2015       pnote->note.descsz = (bfd_get_32 (abfd, in + 4) + 3) & ~3;
2016       pnote->note.type   =  bfd_get_32 (abfd, in + 8);
2017
2018       if (pnote->note.type    != NT_GNU_BUILD_ATTRIBUTE_OPEN
2019           && pnote->note.type != NT_GNU_BUILD_ATTRIBUTE_FUNC)
2020         {
2021           err = _("corrupt GNU build attribute note: wrong note type");
2022           goto done;
2023         }
2024
2025       if (pnote->note.namesz + pnote->note.descsz + 12 > remain)
2026         {
2027           err = _("corrupt GNU build attribute note: note too big");
2028           goto done;
2029         }
2030
2031       if (pnote->note.namesz < 2)
2032         {
2033           err = _("corrupt GNU build attribute note: name too small");
2034           goto done;
2035         }
2036
2037       pnote->note.namedata = (char *)(in + 12);
2038       pnote->note.descdata = (char *)(in + 12 + pnote->note.namesz);
2039
2040       remain -= 12 + pnote->note.namesz + pnote->note.descsz;
2041       in     += 12 + pnote->note.namesz + pnote->note.descsz;
2042
2043       if (pnote->note.namesz > 2
2044           && pnote->note.namedata[0] == '$'
2045           && pnote->note.namedata[1] == GNU_BUILD_ATTRIBUTE_VERSION
2046           && pnote->note.namedata[2] == '1')
2047         ++ version_1_seen;
2048       else if (pnote->note.namesz > 4
2049                && pnote->note.namedata[0] == 'G'
2050                && pnote->note.namedata[1] == 'A'
2051                && pnote->note.namedata[2] == '$'
2052                && pnote->note.namedata[3] == GNU_BUILD_ATTRIBUTE_VERSION)
2053         {
2054           if (pnote->note.namedata[4] == '2')
2055             ++ version_2_seen;
2056           else if (pnote->note.namedata[4] == '3')
2057             ++ version_3_seen;
2058           else
2059             {
2060               err = _("corrupt GNU build attribute note: unsupported version");
2061               goto done;
2062             }
2063         }
2064
2065       switch (pnote->note.descsz)
2066         {
2067         case 0:
2068           start = end = 0;
2069           break;
2070
2071         case 4:
2072           start = bfd_get_32 (abfd, pnote->note.descdata);
2073           /* FIXME: For version 1 and 2 notes we should try to
2074              calculate the end address by finding a symbol whose
2075              value is START, and then adding in its size.
2076
2077              For now though, since v1 and v2 was not intended to
2078              handle gaps, we chose an artificially large end
2079              address.  */
2080           end = (bfd_vma) -1;
2081           break;
2082           
2083         case 8:
2084           if (! is_64bit (abfd))
2085             {
2086               start = bfd_get_32 (abfd, pnote->note.descdata);
2087               end = bfd_get_32 (abfd, pnote->note.descdata + 4);
2088             }
2089           else
2090             {
2091               start = bfd_get_64 (abfd, pnote->note.descdata);
2092               /* FIXME: For version 1 and 2 notes we should try to
2093                  calculate the end address by finding a symbol whose
2094                  value is START, and then adding in its size.
2095
2096                  For now though, since v1 and v2 was not intended to
2097                  handle gaps, we chose an artificially large end
2098                  address.  */
2099               end = (bfd_vma) -1;
2100             }
2101           break;
2102
2103         case 16:
2104           start = bfd_get_64 (abfd, pnote->note.descdata);
2105           end = bfd_get_64 (abfd, pnote->note.descdata + 8);
2106           break;
2107           
2108         default:
2109           err = _("corrupt GNU build attribute note: bad description size");
2110           goto done;
2111         }
2112
2113       if (is_open_note (pnote))
2114         {
2115           if (start)
2116             previous_open_start = start;
2117
2118           pnote->start = previous_open_start;
2119
2120           if (end)
2121             previous_open_end = end;
2122
2123           pnote->end = previous_open_end;
2124         }
2125       else
2126         {
2127           if (start)
2128             previous_func_start = start;
2129
2130           pnote->start = previous_func_start;
2131
2132           if (end)
2133             previous_func_end = end;
2134
2135           pnote->end = previous_func_end;
2136         }
2137
2138       if (pnote->note.namedata[pnote->note.namesz - 1] != 0)
2139         {
2140           err = _("corrupt GNU build attribute note: name not NUL terminated");
2141           goto done;
2142         }
2143
2144       pnote ++;
2145     }
2146
2147   pnotes_end = pnote;
2148
2149   /* Check that the notes are valid.  */
2150   if (remain != 0)
2151     {
2152       err = _("corrupt GNU build attribute notes: excess data at end");
2153       goto done;
2154     }
2155
2156   if (version_1_seen == 0 && version_2_seen == 0 && version_3_seen == 0)
2157     {
2158       err = _("bad GNU build attribute notes: no known versions detected");
2159       goto done;
2160     }
2161
2162   if ((version_1_seen > 0 && version_2_seen > 0)
2163       || (version_1_seen > 0 && version_3_seen > 0)
2164       || (version_2_seen > 0 && version_3_seen > 0))
2165     {
2166       err = _("bad GNU build attribute notes: multiple different versions");
2167       goto done;
2168     }
2169
2170   /* Merging is only needed if there is more than one version note...  */
2171   if (version_1_seen == 1 || version_2_seen == 1 || version_3_seen == 1)
2172     goto done;
2173
2174   attribute_type_byte = version_1_seen ? 1 : 3;
2175   val_start = attribute_type_byte + 1;
2176
2177   /* The first note should be the first version note.  */
2178   if (pnotes[0].note.namedata[attribute_type_byte] != GNU_BUILD_ATTRIBUTE_VERSION)
2179     {
2180       err = _("bad GNU build attribute notes: first note not version note");
2181       goto done;
2182     }
2183
2184   /* Now merge the notes.  The rules are:
2185      1. Preserve the ordering of the notes.
2186      2. Preserve any NT_GNU_BUILD_ATTRIBUTE_FUNC notes.
2187      3. Eliminate any NT_GNU_BUILD_ATTRIBUTE_OPEN notes that have the same
2188         full name field as the immediately preceeding note with the same type
2189         of name and whose address ranges coincide.
2190         IE - if there are gaps in the coverage of the notes, then these gaps
2191         must be preserved.
2192      4. Combine the numeric value of any NT_GNU_BUILD_ATTRIBUTE_OPEN notes
2193         of type GNU_BUILD_ATTRIBUTE_STACK_SIZE.
2194      5. If an NT_GNU_BUILD_ATTRIBUTE_OPEN note is going to be preserved and
2195         its description field is empty then the nearest preceeding OPEN note
2196         with a non-empty description field must also be preserved *OR* the
2197         description field of the note must be changed to contain the starting
2198         address to which it refers.
2199      6. Notes with the same start and end address can be deleted.  */
2200   for (pnote = pnotes + 1; pnote < pnotes_end; pnote ++)
2201     {
2202       int                      note_type;
2203       objcopy_internal_note *  back;
2204       objcopy_internal_note *  prev_open_with_range = NULL;
2205
2206       /* Rule 6 - delete 0-range notes.  */
2207       if (pnote->start == pnote->end)
2208         {
2209           duplicate_found = TRUE;
2210           pnote->note.type = 0;
2211           continue;
2212         }
2213
2214       /* Rule 2 - preserve function notes.  */
2215       if (! is_open_note (pnote))
2216         {
2217           int iter;
2218
2219           /* Check to see if there is an identical previous function note.
2220              This can happen with overlays for example.  */
2221           for (iter = 0, back = pnote -1; back >= pnotes; back --)
2222             {
2223               if (back->start == pnote->start
2224                   && back->end == pnote->end
2225                   && back->note.namesz == pnote->note.namesz
2226                   && memcmp (back->note.namedata, pnote->note.namedata, pnote->note.namesz) == 0)
2227                 {
2228  fprintf (stderr, "DUP FUNXC\n");
2229                   duplicate_found = TRUE;
2230                   pnote->note.type = 0;
2231                   break;
2232                 }
2233
2234               /* Don't scan too far back however.  */
2235               if (iter ++ > 16)
2236                 break;
2237             }
2238           continue;
2239         }
2240
2241       note_type = pnote->note.namedata[attribute_type_byte];
2242
2243       /* Scan backwards from pnote, looking for duplicates.
2244          Clear the type field of any found - but do not delete them just yet.  */
2245       for (back = pnote - 1; back >= pnotes; back --)
2246         {
2247           int back_type = back->note.namedata[attribute_type_byte];
2248
2249           /* If this is the first open note with an address
2250              range that we have encountered then record it.  */
2251           if (prev_open_with_range == NULL
2252               && back->note.descsz > 0
2253               && ! is_func_note (back))
2254             prev_open_with_range = back;
2255
2256           if (! is_open_note (back))
2257             continue;
2258
2259           /* If the two notes are different then keep on searching.  */
2260           if (back_type != note_type)
2261             continue;
2262
2263           /* Rule 4 - combine stack size notes.  */
2264           if (back_type == GNU_BUILD_ATTRIBUTE_STACK_SIZE)
2265             {
2266               unsigned char * name;
2267               unsigned long   note_val;
2268               unsigned long   back_val;
2269               unsigned int    shift;
2270               unsigned int    bytes;
2271               unsigned long   byte;
2272
2273               for (shift = 0, note_val = 0,
2274                      bytes = pnote->note.namesz - val_start,
2275                      name = (unsigned char *) pnote->note.namedata + val_start;
2276                    bytes--;)
2277                 {
2278                   byte = (* name ++) & 0xff;
2279                   note_val |= byte << shift;
2280                   shift += 8;
2281                 }
2282
2283               for (shift = 0, back_val = 0,
2284                      bytes = back->note.namesz - val_start,
2285                      name = (unsigned char *) back->note.namedata + val_start;
2286                    bytes--;)
2287                 {
2288                   byte = (* name ++) & 0xff;
2289                   back_val |= byte << shift;
2290                   shift += 8;
2291                 }
2292
2293               back_val += note_val;
2294               if (num_bytes (back_val) >= back->note.namesz - val_start)
2295                 {
2296                   /* We have a problem - the new value requires more bytes of
2297                      storage in the name field than are available.  Currently
2298                      we have no way of fixing this, so we just preserve both
2299                      notes.  */
2300                   continue;
2301                 }
2302
2303               /* Write the new val into back.  */
2304               name = (unsigned char *) back->note.namedata + val_start;
2305               while (name < (unsigned char *) back->note.namedata
2306                      + back->note.namesz)
2307                 {
2308                   byte = back_val & 0xff;
2309                   * name ++ = byte;
2310                   if (back_val == 0)
2311                     break;
2312                   back_val >>= 8;
2313                 }
2314
2315               duplicate_found = TRUE;
2316               pnote->note.type = 0;
2317               break;
2318             }
2319
2320           /* Rule 3 - combine identical open notes.  */
2321           if (back->note.namesz == pnote->note.namesz
2322               && memcmp (back->note.namedata,
2323                          pnote->note.namedata, back->note.namesz) == 0
2324               && ! gap_exists (back, pnote))
2325             {
2326               duplicate_found = TRUE;
2327               pnote->note.type = 0;
2328
2329               if (pnote->end > back->end)
2330                 back->end = pnote->end;
2331
2332               if (version_3_seen)
2333                 back->modified = TRUE;
2334               break;
2335             }
2336
2337           /* Rule 5 - Since we are keeping this note we must check to see
2338              if its description refers back to an earlier OPEN version
2339              note that has been scheduled for deletion.  If so then we
2340              must make sure that version note is also preserved.  */
2341           if (version_3_seen)
2342             {
2343               /* As of version 3 we can just
2344                  move the range into the note.  */
2345               pnote->modified = TRUE;
2346               pnote->note.type = NT_GNU_BUILD_ATTRIBUTE_FUNC;
2347               back->modified = TRUE;
2348               back->note.type = NT_GNU_BUILD_ATTRIBUTE_FUNC;
2349             }
2350           else
2351             {
2352               if (pnote->note.descsz == 0
2353                   && prev_open_with_range != NULL
2354                   && prev_open_with_range->note.type == 0)
2355                 prev_open_with_range->note.type = NT_GNU_BUILD_ATTRIBUTE_OPEN;
2356             }
2357
2358           /* We have found a similar attribute but the details do not match.
2359              Stop searching backwards.  */
2360           break;
2361         }
2362     }
2363
2364   if (duplicate_found)
2365     {
2366       bfd_byte *     new_contents;
2367       bfd_byte *     old;
2368       bfd_byte *     new;
2369       bfd_size_type  new_size;
2370       bfd_vma        prev_start = 0;
2371       bfd_vma        prev_end = 0;
2372
2373       /* Eliminate the duplicates.  */
2374       new = new_contents = xmalloc (size);
2375       for (pnote = pnotes, old = contents;
2376            pnote < pnotes_end;
2377            pnote ++)
2378         {
2379           bfd_size_type note_size = 12 + pnote->note.namesz + pnote->note.descsz;
2380
2381           if (pnote->note.type != 0)
2382             {
2383               if (pnote->modified)
2384                 {
2385                   /* If the note has been modified then we must copy it by
2386                      hand, potentially adding in a new description field.  */
2387                   if (pnote->start == prev_start && pnote->end == prev_end)
2388                     {
2389                       bfd_put_32 (abfd, pnote->note.namesz, new);
2390                       bfd_put_32 (abfd, 0, new + 4);
2391                       bfd_put_32 (abfd, pnote->note.type, new + 8);
2392                       new += 12;
2393                       memcpy (new, pnote->note.namedata, pnote->note.namesz);
2394                       new += pnote->note.namesz;
2395                     }
2396                   else
2397                     {
2398                       bfd_put_32 (abfd, pnote->note.namesz, new);
2399                       bfd_put_32 (abfd, is_64bit (abfd) ? 16 : 8, new + 4);
2400                       bfd_put_32 (abfd, pnote->note.type, new + 8);
2401                       new += 12;
2402                       memcpy (new, pnote->note.namedata, pnote->note.namesz);
2403                       new += pnote->note.namesz;
2404                       if (is_64bit (abfd))
2405                         {
2406                           bfd_put_64 (abfd, pnote->start, new);
2407                           bfd_put_64 (abfd, pnote->end, new + 8);
2408                           new += 16;
2409                         }
2410                       else
2411                         {
2412                           bfd_put_32 (abfd, pnote->start, new);
2413                           bfd_put_32 (abfd, pnote->end, new + 4);
2414                           new += 8;
2415                         }
2416                     }
2417                 }
2418               else
2419                 {
2420                   memcpy (new, old, note_size);
2421                   new += note_size;
2422                 }
2423               prev_start = pnote->start;
2424               prev_end = pnote->end;
2425             }
2426
2427           old += note_size;
2428         }
2429
2430       new_size = new - new_contents;
2431       memcpy (contents, new_contents, new_size);
2432       size = new_size;
2433       free (new_contents);
2434     }
2435
2436  done:
2437   if (err)
2438     {
2439       bfd_set_error (bfd_error_bad_value);
2440       bfd_nonfatal_message (NULL, abfd, sec, err);
2441       status = 1;
2442     }
2443
2444   free (pnotes);
2445   return size;
2446 }
2447
2448 /* Copy object file IBFD onto OBFD.
2449    Returns TRUE upon success, FALSE otherwise.  */
2450
2451 static bfd_boolean
2452 copy_object (bfd *ibfd, bfd *obfd, const bfd_arch_info_type *input_arch)
2453 {
2454   bfd_vma start;
2455   long symcount;
2456   asection **osections = NULL;
2457   asection *osec;
2458   asection *gnu_debuglink_section = NULL;
2459   bfd_size_type *gaps = NULL;
2460   bfd_size_type max_gap = 0;
2461   long symsize;
2462   void *dhandle;
2463   enum bfd_architecture iarch;
2464   unsigned int imach;
2465   unsigned int c, i;
2466
2467   if (ibfd->xvec->byteorder != obfd->xvec->byteorder
2468       && ibfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN
2469       && obfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN)
2470     {
2471       /* PR 17636: Call non-fatal so that we return to our parent who
2472          may need to tidy temporary files.  */
2473       non_fatal (_("Unable to change endianness of input file(s)"));
2474       return FALSE;
2475     }
2476
2477   if (!bfd_set_format (obfd, bfd_get_format (ibfd)))
2478     {
2479       bfd_nonfatal_message (NULL, obfd, NULL, NULL);
2480       return FALSE;
2481     }
2482
2483   if (ibfd->sections == NULL)
2484     {
2485       non_fatal (_("error: the input file '%s' has no sections"),
2486                  bfd_get_archive_filename (ibfd));
2487       return FALSE;
2488     }
2489
2490   if (ibfd->xvec->flavour != bfd_target_elf_flavour)
2491     {
2492       if ((do_debug_sections & compress) != 0
2493           && do_debug_sections != compress)
2494         {
2495           non_fatal (_("--compress-debug-sections=[zlib|zlib-gnu|zlib-gabi] is unsupported on `%s'"),
2496                      bfd_get_archive_filename (ibfd));
2497           return FALSE;
2498         }
2499
2500       if (do_elf_stt_common)
2501         {
2502           non_fatal (_("--elf-stt-common=[yes|no] is unsupported on `%s'"),
2503                      bfd_get_archive_filename (ibfd));
2504           return FALSE;
2505         }
2506     }
2507
2508   if (verbose)
2509     printf (_("copy from `%s' [%s] to `%s' [%s]\n"),
2510             bfd_get_archive_filename (ibfd), bfd_get_target (ibfd),
2511             bfd_get_filename (obfd), bfd_get_target (obfd));
2512
2513   if (extract_symbol)
2514     start = 0;
2515   else
2516     {
2517       if (set_start_set)
2518         start = set_start;
2519       else
2520         start = bfd_get_start_address (ibfd);
2521       start += change_start;
2522     }
2523
2524   /* Neither the start address nor the flags
2525      need to be set for a core file.  */
2526   if (bfd_get_format (obfd) != bfd_core)
2527     {
2528       flagword flags;
2529
2530       flags = bfd_get_file_flags (ibfd);
2531       flags |= bfd_flags_to_set;
2532       flags &= ~bfd_flags_to_clear;
2533       flags &= bfd_applicable_file_flags (obfd);
2534
2535       if (strip_symbols == STRIP_ALL)
2536         flags &= ~HAS_RELOC;
2537
2538       if (!bfd_set_start_address (obfd, start)
2539           || !bfd_set_file_flags (obfd, flags))
2540         {
2541           bfd_nonfatal_message (NULL, ibfd, NULL, NULL);
2542           return FALSE;
2543         }
2544     }
2545
2546   /* Copy architecture of input file to output file.  */
2547   iarch = bfd_get_arch (ibfd);
2548   imach = bfd_get_mach (ibfd);
2549   if (input_arch)
2550     {
2551       if (bfd_get_arch_info (ibfd) == NULL
2552           || bfd_get_arch_info (ibfd)->arch == bfd_arch_unknown)
2553         {
2554           iarch = input_arch->arch;
2555           imach = input_arch->mach;
2556         }
2557       else
2558         non_fatal (_("Input file `%s' ignores binary architecture parameter."),
2559                    bfd_get_archive_filename (ibfd));
2560     }
2561   if (!bfd_set_arch_mach (obfd, iarch, imach)
2562       && (ibfd->target_defaulted
2563           || bfd_get_arch (ibfd) != bfd_get_arch (obfd)))
2564     {
2565       if (bfd_get_arch (ibfd) == bfd_arch_unknown)
2566         non_fatal (_("Unable to recognise the format of the input file `%s'"),
2567                    bfd_get_archive_filename (ibfd));
2568       else
2569         non_fatal (_("Output file cannot represent architecture `%s'"),
2570                    bfd_printable_arch_mach (bfd_get_arch (ibfd),
2571                                             bfd_get_mach (ibfd)));
2572       return FALSE;
2573     }
2574
2575   if (!bfd_set_format (obfd, bfd_get_format (ibfd)))
2576     {
2577       bfd_nonfatal_message (NULL, ibfd, NULL, NULL);
2578       return FALSE;
2579     }
2580
2581   if (bfd_get_flavour (obfd) == bfd_target_coff_flavour
2582       && bfd_pei_p (obfd))
2583     {
2584       /* Set up PE parameters.  */
2585       pe_data_type *pe = pe_data (obfd);
2586
2587       /* Copy PE parameters before changing them.  */
2588       if (ibfd->xvec->flavour == bfd_target_coff_flavour
2589           && bfd_pei_p (ibfd))
2590         pe->pe_opthdr = pe_data (ibfd)->pe_opthdr;
2591
2592       if (pe_file_alignment != (bfd_vma) -1)
2593         pe->pe_opthdr.FileAlignment = pe_file_alignment;
2594       else
2595         pe_file_alignment = PE_DEF_FILE_ALIGNMENT;
2596
2597       if (pe_heap_commit != (bfd_vma) -1)
2598         pe->pe_opthdr.SizeOfHeapCommit = pe_heap_commit;
2599
2600       if (pe_heap_reserve != (bfd_vma) -1)
2601         pe->pe_opthdr.SizeOfHeapCommit = pe_heap_reserve;
2602
2603       if (pe_image_base != (bfd_vma) -1)
2604         pe->pe_opthdr.ImageBase = pe_image_base;
2605
2606       if (pe_section_alignment != (bfd_vma) -1)
2607         pe->pe_opthdr.SectionAlignment = pe_section_alignment;
2608       else
2609         pe_section_alignment = PE_DEF_SECTION_ALIGNMENT;
2610
2611       if (pe_stack_commit != (bfd_vma) -1)
2612         pe->pe_opthdr.SizeOfStackCommit = pe_stack_commit;
2613
2614       if (pe_stack_reserve != (bfd_vma) -1)
2615         pe->pe_opthdr.SizeOfStackCommit = pe_stack_reserve;
2616
2617       if (pe_subsystem != -1)
2618         pe->pe_opthdr.Subsystem = pe_subsystem;
2619
2620       if (pe_major_subsystem_version != -1)
2621         pe->pe_opthdr.MajorSubsystemVersion = pe_major_subsystem_version;
2622
2623       if (pe_minor_subsystem_version != -1)
2624         pe->pe_opthdr.MinorSubsystemVersion = pe_minor_subsystem_version;
2625
2626       if (pe_file_alignment > pe_section_alignment)
2627         {
2628           char file_alignment[20], section_alignment[20];
2629
2630           sprintf_vma (file_alignment, pe_file_alignment);
2631           sprintf_vma (section_alignment, pe_section_alignment);
2632           non_fatal (_("warning: file alignment (0x%s) > section alignment (0x%s)"),
2633
2634                      file_alignment, section_alignment);
2635         }
2636     }
2637
2638   if (isympp)
2639     free (isympp);
2640
2641   if (osympp != isympp)
2642     free (osympp);
2643
2644   isympp = NULL;
2645   osympp = NULL;
2646
2647   symsize = bfd_get_symtab_upper_bound (ibfd);
2648   if (symsize < 0)
2649     {
2650       bfd_nonfatal_message (NULL, ibfd, NULL, NULL);
2651       return FALSE;
2652     }
2653
2654   osympp = isympp = (asymbol **) xmalloc (symsize);
2655   symcount = bfd_canonicalize_symtab (ibfd, isympp);
2656   if (symcount < 0)
2657     {
2658       bfd_nonfatal_message (NULL, ibfd, NULL, NULL);
2659       return FALSE;
2660     }
2661   /* PR 17512: file:  d6323821
2662      If the symbol table could not be loaded do not pretend that we have
2663      any symbols.  This trips us up later on when we load the relocs.  */
2664   if (symcount == 0)
2665     {
2666       free (isympp);
2667       osympp = isympp = NULL;
2668     }
2669
2670   /* BFD mandates that all output sections be created and sizes set before
2671      any output is done.  Thus, we traverse all sections multiple times.  */
2672   bfd_map_over_sections (ibfd, setup_section, obfd);
2673
2674   if (!extract_symbol)
2675     setup_bfd_headers (ibfd, obfd);
2676
2677   if (add_sections != NULL)
2678     {
2679       struct section_add *padd;
2680       struct section_list *pset;
2681
2682       for (padd = add_sections; padd != NULL; padd = padd->next)
2683         {
2684           flagword flags;
2685
2686           pset = find_section_list (padd->name, FALSE,
2687                                     SECTION_CONTEXT_SET_FLAGS);
2688           if (pset != NULL)
2689             flags = pset->flags | SEC_HAS_CONTENTS;
2690           else
2691             flags = SEC_HAS_CONTENTS | SEC_READONLY | SEC_DATA;
2692
2693           /* bfd_make_section_with_flags() does not return very helpful
2694              error codes, so check for the most likely user error first.  */
2695           if (bfd_get_section_by_name (obfd, padd->name))
2696             {
2697               bfd_nonfatal_message (NULL, obfd, NULL,
2698                                     _("can't add section '%s'"), padd->name);
2699               return FALSE;
2700             }
2701           else
2702             {
2703               /* We use LINKER_CREATED here so that the backend hooks
2704                  will create any special section type information,
2705                  instead of presuming we know what we're doing merely
2706                  because we set the flags.  */
2707               padd->section = bfd_make_section_with_flags
2708                 (obfd, padd->name, flags | SEC_LINKER_CREATED);
2709               if (padd->section == NULL)
2710                 {
2711                   bfd_nonfatal_message (NULL, obfd, NULL,
2712                                         _("can't create section `%s'"),
2713                                         padd->name);
2714                   return FALSE;
2715                 }
2716             }
2717
2718           if (! bfd_set_section_size (obfd, padd->section, padd->size))
2719             {
2720               bfd_nonfatal_message (NULL, obfd, padd->section, NULL);
2721               return FALSE;
2722             }
2723
2724           pset = find_section_list (padd->name, FALSE,
2725                                     SECTION_CONTEXT_SET_VMA | SECTION_CONTEXT_ALTER_VMA);
2726           if (pset != NULL
2727               && ! bfd_set_section_vma (obfd, padd->section, pset->vma_val))
2728             {
2729               bfd_nonfatal_message (NULL, obfd, padd->section, NULL);
2730               return FALSE;
2731             }
2732
2733           pset = find_section_list (padd->name, FALSE,
2734                                     SECTION_CONTEXT_SET_LMA | SECTION_CONTEXT_ALTER_LMA);
2735           if (pset != NULL)
2736             {
2737               padd->section->lma = pset->lma_val;
2738
2739               if (! bfd_set_section_alignment
2740                   (obfd, padd->section,
2741                    bfd_section_alignment (obfd, padd->section)))
2742                 {
2743                   bfd_nonfatal_message (NULL, obfd, padd->section, NULL);
2744                   return FALSE;
2745                 }
2746             }
2747         }
2748     }
2749
2750   if (update_sections != NULL)
2751     {
2752       struct section_add *pupdate;
2753
2754       for (pupdate = update_sections;
2755            pupdate != NULL;
2756            pupdate = pupdate->next)
2757         {
2758           pupdate->section = bfd_get_section_by_name (ibfd, pupdate->name);
2759           if (pupdate->section == NULL)
2760             {
2761               non_fatal (_("error: %s not found, can't be updated"), pupdate->name);
2762               return FALSE;
2763             }
2764
2765           osec = pupdate->section->output_section;
2766           if (! bfd_set_section_size (obfd, osec, pupdate->size))
2767             {
2768               bfd_nonfatal_message (NULL, obfd, osec, NULL);
2769               return FALSE;
2770             }
2771         }
2772     }
2773
2774   if (merge_notes)
2775     {
2776       /* This palaver is necessary because we must set the output
2777          section size first, before its contents are ready.  */
2778       osec = bfd_get_section_by_name (ibfd, GNU_BUILD_ATTRS_SECTION_NAME);
2779       if (osec && is_merged_note_section (ibfd, osec))
2780         {
2781           bfd_size_type size;
2782           
2783           size = bfd_get_section_size (osec);
2784           if (size == 0)
2785             {
2786               bfd_nonfatal_message (NULL, ibfd, osec, _("warning: note section is empty"));
2787               merge_notes = FALSE;
2788             }
2789           else if (! bfd_get_full_section_contents (ibfd, osec, & merged_notes))
2790             {
2791               bfd_nonfatal_message (NULL, ibfd, osec, _("warning: could not load note section"));
2792               free (merged_notes);
2793               merged_notes = NULL;
2794               merge_notes = FALSE;
2795             }
2796           else
2797             {
2798               merged_size = merge_gnu_build_notes (ibfd, osec, size, merged_notes);
2799               if (merged_size == size)
2800                 {
2801                   /* Merging achieves nothing.  */
2802                   free (merged_notes);
2803                   merged_notes = NULL;
2804                   merge_notes = FALSE;
2805                   merged_size = 0;
2806                 }
2807               else
2808                 {
2809                   if (osec->output_section == NULL
2810                       || ! bfd_set_section_size (obfd, osec->output_section, merged_size))
2811                     {
2812                       bfd_nonfatal_message (NULL, obfd, osec, _("warning: failed to set merged notes size"));
2813                       free (merged_notes);
2814                       merged_notes = NULL;
2815                       merge_notes = FALSE;
2816                       merged_size = 0;
2817                     }
2818                 }
2819             }
2820         }
2821     }
2822
2823   if (dump_sections != NULL)
2824     {
2825       struct section_add * pdump;
2826
2827       for (pdump = dump_sections; pdump != NULL; pdump = pdump->next)
2828         {
2829           osec = bfd_get_section_by_name (ibfd, pdump->name);
2830           if (osec == NULL)
2831             {
2832               bfd_nonfatal_message (NULL, ibfd, NULL,
2833                                     _("can't dump section '%s' - it does not exist"),
2834                                     pdump->name);
2835               continue;
2836             }
2837
2838           if ((bfd_get_section_flags (ibfd, osec) & SEC_HAS_CONTENTS) == 0)
2839             {
2840               bfd_nonfatal_message (NULL, ibfd, osec,
2841                                     _("can't dump section - it has no contents"));
2842               continue;
2843             }
2844
2845           bfd_size_type size = bfd_get_section_size (osec);
2846           if (size == 0)
2847             {
2848               bfd_nonfatal_message (NULL, ibfd, osec,
2849                                     _("can't dump section - it is empty"));
2850               continue;
2851             }
2852
2853           FILE * f;
2854           f = fopen (pdump->filename, FOPEN_WB);
2855           if (f == NULL)
2856             {
2857               bfd_nonfatal_message (pdump->filename, NULL, NULL,
2858                                     _("could not open section dump file"));
2859               continue;
2860             }
2861
2862           bfd_byte *contents;
2863           if (bfd_malloc_and_get_section (ibfd, osec, &contents))
2864             {
2865               if (fwrite (contents, 1, size, f) != size)
2866                 {
2867                   non_fatal (_("error writing section contents to %s (error: %s)"),
2868                              pdump->filename,
2869                              strerror (errno));
2870                   free (contents);
2871                   fclose (f);
2872                   return FALSE;
2873                 }
2874             }
2875           else
2876             bfd_nonfatal_message (NULL, ibfd, osec,
2877                                   _("could not retrieve section contents"));
2878
2879           fclose (f);
2880           free (contents);
2881         }
2882     }
2883
2884   if (gnu_debuglink_filename != NULL)
2885     {
2886       /* PR 15125: Give a helpful warning message if
2887          the debuglink section already exists, and
2888          allow the rest of the copy to complete.  */
2889       if (bfd_get_section_by_name (obfd, ".gnu_debuglink"))
2890         {
2891           non_fatal (_("%s: debuglink section already exists"),
2892                      bfd_get_filename (obfd));
2893           gnu_debuglink_filename = NULL;
2894         }
2895       else
2896         {
2897           gnu_debuglink_section = bfd_create_gnu_debuglink_section
2898             (obfd, gnu_debuglink_filename);
2899
2900           if (gnu_debuglink_section == NULL)
2901             {
2902               bfd_nonfatal_message (NULL, obfd, NULL,
2903                                     _("cannot create debug link section `%s'"),
2904                                     gnu_debuglink_filename);
2905               return FALSE;
2906             }
2907
2908           /* Special processing for PE format files.  We
2909              have no way to distinguish PE from COFF here.  */
2910           if (bfd_get_flavour (obfd) == bfd_target_coff_flavour)
2911             {
2912               bfd_vma debuglink_vma;
2913               asection * highest_section;
2914
2915               /* The PE spec requires that all sections be adjacent and sorted
2916                  in ascending order of VMA.  It also specifies that debug
2917                  sections should be last.  This is despite the fact that debug
2918                  sections are not loaded into memory and so in theory have no
2919                  use for a VMA.
2920
2921                  This means that the debuglink section must be given a non-zero
2922                  VMA which makes it contiguous with other debug sections.  So
2923                  walk the current section list, find the section with the
2924                  highest VMA and start the debuglink section after that one.  */
2925               for (osec = obfd->sections, highest_section = NULL;
2926                    osec != NULL;
2927                    osec = osec->next)
2928                 if (osec->vma > 0
2929                     && (highest_section == NULL
2930                         || osec->vma > highest_section->vma))
2931                   highest_section = osec;
2932
2933               if (highest_section)
2934                 debuglink_vma = BFD_ALIGN (highest_section->vma
2935                                            + highest_section->size,
2936                                            /* FIXME: We ought to be using
2937                                               COFF_PAGE_SIZE here or maybe
2938                                               bfd_get_section_alignment() (if it
2939                                               was set) but since this is for PE
2940                                               and we know the required alignment
2941                                               it is easier just to hard code it.  */
2942                                            0x1000);
2943               else
2944                 /* Umm, not sure what to do in this case.  */
2945                 debuglink_vma = 0x1000;
2946
2947               bfd_set_section_vma (obfd, gnu_debuglink_section, debuglink_vma);
2948             }
2949         }
2950     }
2951
2952   c = bfd_count_sections (obfd);
2953   if (c != 0
2954       && (gap_fill_set || pad_to_set))
2955     {
2956       asection **set;
2957
2958       /* We must fill in gaps between the sections and/or we must pad
2959          the last section to a specified address.  We do this by
2960          grabbing a list of the sections, sorting them by VMA, and
2961          increasing the section sizes as required to fill the gaps.
2962          We write out the gap contents below.  */
2963
2964       osections = (asection **) xmalloc (c * sizeof (asection *));
2965       set = osections;
2966       bfd_map_over_sections (obfd, get_sections, &set);
2967
2968       qsort (osections, c, sizeof (asection *), compare_section_lma);
2969
2970       gaps = (bfd_size_type *) xmalloc (c * sizeof (bfd_size_type));
2971       memset (gaps, 0, c * sizeof (bfd_size_type));
2972
2973       if (gap_fill_set)
2974         {
2975           for (i = 0; i < c - 1; i++)
2976             {
2977               flagword flags;
2978               bfd_size_type size;
2979               bfd_vma gap_start, gap_stop;
2980
2981               flags = bfd_get_section_flags (obfd, osections[i]);
2982               if ((flags & SEC_HAS_CONTENTS) == 0
2983                   || (flags & SEC_LOAD) == 0)
2984                 continue;
2985
2986               size = bfd_section_size (obfd, osections[i]);
2987               gap_start = bfd_section_lma (obfd, osections[i]) + size;
2988               gap_stop = bfd_section_lma (obfd, osections[i + 1]);
2989               if (gap_start < gap_stop)
2990                 {
2991                   if (! bfd_set_section_size (obfd, osections[i],
2992                                               size + (gap_stop - gap_start)))
2993                     {
2994                       bfd_nonfatal_message (NULL, obfd, osections[i],
2995                                             _("Can't fill gap after section"));
2996                       status = 1;
2997                       break;
2998                     }
2999                   gaps[i] = gap_stop - gap_start;
3000                   if (max_gap < gap_stop - gap_start)
3001                     max_gap = gap_stop - gap_start;
3002                 }
3003             }
3004         }
3005
3006       if (pad_to_set)
3007         {
3008           bfd_vma lma;
3009           bfd_size_type size;
3010
3011           lma = bfd_section_lma (obfd, osections[c - 1]);
3012           size = bfd_section_size (obfd, osections[c - 1]);
3013           if (lma + size < pad_to)
3014             {
3015               if (! bfd_set_section_size (obfd, osections[c - 1],
3016                                           pad_to - lma))
3017                 {
3018                   bfd_nonfatal_message (NULL, obfd, osections[c - 1],
3019                                         _("can't add padding"));
3020                   status = 1;
3021                 }
3022               else
3023                 {
3024                   gaps[c - 1] = pad_to - (lma + size);
3025                   if (max_gap < pad_to - (lma + size))
3026                     max_gap = pad_to - (lma + size);
3027                 }
3028             }
3029         }
3030     }
3031
3032   /* Symbol filtering must happen after the output sections
3033      have been created, but before their contents are set.  */
3034   dhandle = NULL;
3035   if (convert_debugging)
3036     dhandle = read_debugging_info (ibfd, isympp, symcount, FALSE);
3037
3038   if (strip_symbols == STRIP_DEBUG
3039       || strip_symbols == STRIP_ALL
3040       || strip_symbols == STRIP_UNNEEDED
3041       || strip_symbols == STRIP_NONDEBUG
3042       || strip_symbols == STRIP_DWO
3043       || strip_symbols == STRIP_NONDWO
3044       || discard_locals != LOCALS_UNDEF
3045       || localize_hidden
3046       || htab_elements (strip_specific_htab) != 0
3047       || htab_elements (keep_specific_htab) != 0
3048       || htab_elements (localize_specific_htab) != 0
3049       || htab_elements (globalize_specific_htab) != 0
3050       || htab_elements (keepglobal_specific_htab) != 0
3051       || htab_elements (weaken_specific_htab) != 0
3052       || htab_elements (redefine_specific_htab) != 0
3053       || prefix_symbols_string
3054       || sections_removed
3055       || sections_copied
3056       || convert_debugging
3057       || change_leading_char
3058       || remove_leading_char
3059       || section_rename_list
3060       || weaken
3061       || add_symbols)
3062     {
3063       /* Mark symbols used in output relocations so that they
3064          are kept, even if they are local labels or static symbols.
3065
3066          Note we iterate over the input sections examining their
3067          relocations since the relocations for the output sections
3068          haven't been set yet.  mark_symbols_used_in_relocations will
3069          ignore input sections which have no corresponding output
3070          section.  */
3071       if (strip_symbols != STRIP_ALL)
3072         {
3073           bfd_set_error (bfd_error_no_error);
3074           bfd_map_over_sections (ibfd,
3075                                  mark_symbols_used_in_relocations,
3076                                  isympp);
3077           if (bfd_get_error () != bfd_error_no_error)
3078             {
3079               status = 1;
3080               return FALSE;
3081             }
3082         }
3083
3084       osympp = (asymbol **) xmalloc ((symcount + add_symbols + 1) * sizeof (asymbol *));
3085       symcount = filter_symbols (ibfd, obfd, osympp, isympp, symcount);
3086     }
3087
3088   if (convert_debugging && dhandle != NULL)
3089     {
3090       bfd_boolean res;
3091
3092       res = write_debugging_info (obfd, dhandle, &symcount, &osympp);
3093
3094       free (dhandle);
3095       dhandle = NULL; /* Paranoia...  */
3096
3097       if (! res)
3098         {
3099           status = 1;
3100           return FALSE;
3101         }
3102     }
3103
3104   bfd_set_symtab (obfd, osympp, symcount);
3105
3106   /* This has to happen before section positions are set.  */
3107   bfd_map_over_sections (ibfd, copy_relocations_in_section, obfd);
3108
3109   /* This has to happen after the symbol table has been set.  */
3110   bfd_map_over_sections (ibfd, copy_section, obfd);
3111
3112   if (add_sections != NULL)
3113     {
3114       struct section_add *padd;
3115
3116       for (padd = add_sections; padd != NULL; padd = padd->next)
3117         {
3118           if (! bfd_set_section_contents (obfd, padd->section, padd->contents,
3119                                           0, padd->size))
3120             {
3121               bfd_nonfatal_message (NULL, obfd, padd->section, NULL);
3122               return FALSE;
3123             }
3124         }
3125     }
3126
3127   if (update_sections != NULL)
3128     {
3129       struct section_add *pupdate;
3130
3131       for (pupdate = update_sections;
3132            pupdate != NULL;
3133            pupdate = pupdate->next)
3134         {
3135           osec = pupdate->section->output_section;
3136           if (! bfd_set_section_contents (obfd, osec, pupdate->contents,
3137                                           0, pupdate->size))
3138             {
3139               bfd_nonfatal_message (NULL, obfd, osec, NULL);
3140               return FALSE;
3141             }
3142         }
3143     }
3144
3145   if (merge_notes)
3146     {
3147       osec = bfd_get_section_by_name (obfd, GNU_BUILD_ATTRS_SECTION_NAME);
3148       if (osec && is_merged_note_section (obfd, osec))
3149         {
3150           if (! bfd_set_section_contents (obfd, osec, merged_notes, 0, merged_size))
3151             {
3152               bfd_nonfatal_message (NULL, obfd, osec, _("error: failed to copy merged notes into output"));
3153               return FALSE;
3154             }
3155         }
3156       else if (! is_strip)
3157         bfd_nonfatal_message (NULL, obfd, osec, _("could not find any mergeable note sections"));
3158       free (merged_notes);
3159       merged_notes = NULL;
3160       merge_notes = FALSE;
3161     }
3162
3163   if (gnu_debuglink_filename != NULL)
3164     {
3165       if (! bfd_fill_in_gnu_debuglink_section
3166           (obfd, gnu_debuglink_section, gnu_debuglink_filename))
3167         {
3168           bfd_nonfatal_message (NULL, obfd, NULL,
3169                                 _("cannot fill debug link section `%s'"),
3170                                 gnu_debuglink_filename);
3171           return FALSE;
3172         }
3173     }
3174
3175   if (gap_fill_set || pad_to_set)
3176     {
3177       bfd_byte *buf;
3178
3179       /* Fill in the gaps.  */
3180       if (max_gap > 8192)
3181         max_gap = 8192;
3182       buf = (bfd_byte *) xmalloc (max_gap);
3183       memset (buf, gap_fill, max_gap);
3184
3185       c = bfd_count_sections (obfd);
3186       for (i = 0; i < c; i++)
3187         {
3188           if (gaps[i] != 0)
3189             {
3190               bfd_size_type left;
3191               file_ptr off;
3192
3193               left = gaps[i];
3194               off = bfd_section_size (obfd, osections[i]) - left;
3195
3196               while (left > 0)
3197                 {
3198                   bfd_size_type now;
3199
3200                   if (left > 8192)
3201                     now = 8192;
3202                   else
3203                     now = left;
3204
3205                   if (! bfd_set_section_contents (obfd, osections[i], buf,
3206                                                   off, now))
3207                     {
3208                       bfd_nonfatal_message (NULL, obfd, osections[i], NULL);
3209                       free (buf);
3210                       return FALSE;
3211                     }
3212
3213                   left -= now;
3214                   off += now;
3215                 }
3216             }
3217         }
3218
3219       free (buf);
3220       free (gaps);
3221       gaps = NULL;
3222     }
3223
3224   /* Allow the BFD backend to copy any private data it understands
3225      from the input BFD to the output BFD.  This is done last to
3226      permit the routine to look at the filtered symbol table, which is
3227      important for the ECOFF code at least.  */
3228   if (! bfd_copy_private_bfd_data (ibfd, obfd))
3229     {
3230       bfd_nonfatal_message (NULL, obfd, NULL,
3231                             _("error copying private BFD data"));
3232       return FALSE;
3233     }
3234
3235   /* Switch to the alternate machine code.  We have to do this at the
3236      very end, because we only initialize the header when we create
3237      the first section.  */
3238   if (use_alt_mach_code != 0)
3239     {
3240       if (! bfd_alt_mach_code (obfd, use_alt_mach_code))
3241         {
3242           non_fatal (_("this target does not support %lu alternative machine codes"),
3243                      use_alt_mach_code);
3244           if (bfd_get_flavour (obfd) == bfd_target_elf_flavour)
3245             {
3246               non_fatal (_("treating that number as an absolute e_machine value instead"));
3247               elf_elfheader (obfd)->e_machine = use_alt_mach_code;
3248             }
3249           else
3250             non_fatal (_("ignoring the alternative value"));
3251         }
3252     }
3253
3254   return TRUE;
3255 }
3256
3257 /* Read each archive element in turn from IBFD, copy the
3258    contents to temp file, and keep the temp file handle.
3259    If 'force_output_target' is TRUE then make sure that
3260    all elements in the new archive are of the type
3261    'output_target'.  */
3262
3263 static void
3264 copy_archive (bfd *ibfd, bfd *obfd, const char *output_target,
3265               bfd_boolean force_output_target,
3266               const bfd_arch_info_type *input_arch)
3267 {
3268   struct name_list
3269     {
3270       struct name_list *next;
3271       const char *name;
3272       bfd *obfd;
3273     } *list, *l;
3274   bfd **ptr = &obfd->archive_head;
3275   bfd *this_element;
3276   char *dir;
3277   const char *filename;
3278
3279   /* PR 24281: It is not clear what should happen when copying a thin archive.
3280      One part is straight forward - if the output archive is in a different
3281      directory from the input archive then any relative paths in the library
3282      should be adjusted to the new location.  But if any transformation
3283      options are active (eg strip, rename, add, etc) then the implication is
3284      that these should be applied to the files pointed to by the archive.
3285      But since objcopy is not destructive, this means that new files must be
3286      created, and there is no guidance for the names of the new files.  (Plus
3287      this conflicts with one of the goals of thin libraries - only taking up
3288      a  minimal amount of space in the file system).
3289
3290      So for now we fail if an attempt is made to copy such libraries.  */
3291   if (ibfd->is_thin_archive)
3292     {
3293       status = 1;
3294       bfd_set_error (bfd_error_invalid_operation);
3295       bfd_nonfatal_message (NULL, ibfd, NULL,
3296                             _("sorry: copying thin archives is not currently supported"));
3297       return;
3298     }
3299
3300   /* Make a temp directory to hold the contents.  */
3301   dir = make_tempdir (bfd_get_filename (obfd));
3302   if (dir == NULL)
3303     fatal (_("cannot create tempdir for archive copying (error: %s)"),
3304            strerror (errno));
3305
3306   if (strip_symbols == STRIP_ALL)
3307     obfd->has_armap = FALSE;
3308   else
3309     obfd->has_armap = ibfd->has_armap;
3310   obfd->is_thin_archive = ibfd->is_thin_archive;
3311
3312   if (deterministic)
3313     obfd->flags |= BFD_DETERMINISTIC_OUTPUT;
3314
3315   list = NULL;
3316
3317   this_element = bfd_openr_next_archived_file (ibfd, NULL);
3318
3319   if (!bfd_set_format (obfd, bfd_get_format (ibfd)))
3320     {
3321       status = 1;
3322       bfd_nonfatal_message (NULL, obfd, NULL, NULL);
3323       goto cleanup_and_exit;
3324     }
3325
3326   while (!status && this_element != NULL)
3327     {
3328       char *output_name;
3329       bfd *output_bfd;
3330       bfd *last_element;
3331       struct stat buf;
3332       int stat_status = 0;
3333       bfd_boolean del = TRUE;
3334       bfd_boolean ok_object;
3335
3336       /* PR binutils/17533: Do not allow directory traversal
3337          outside of the current directory tree by archive members.  */
3338       if (! is_valid_archive_path (bfd_get_filename (this_element)))
3339         {
3340           non_fatal (_("illegal pathname found in archive member: %s"),
3341                      bfd_get_filename (this_element));
3342           status = 1;
3343           goto cleanup_and_exit;
3344         }
3345
3346       /* Create an output file for this member.  */
3347       output_name = concat (dir, "/",
3348                             bfd_get_filename (this_element), (char *) 0);
3349
3350       /* If the file already exists, make another temp dir.  */
3351       if (stat (output_name, &buf) >= 0)
3352         {
3353           char * tmpdir = make_tempdir (output_name);
3354
3355           free (output_name);
3356           if (tmpdir == NULL)
3357             {
3358               non_fatal (_("cannot create tempdir for archive copying (error: %s)"),
3359                          strerror (errno));
3360               status = 1;
3361               goto cleanup_and_exit;
3362             }
3363
3364           l = (struct name_list *) xmalloc (sizeof (struct name_list));
3365           l->name = tmpdir;
3366           l->next = list;
3367           l->obfd = NULL;
3368           list = l;
3369           output_name = concat (tmpdir, "/",
3370                                 bfd_get_filename (this_element), (char *) 0);
3371         }
3372
3373       if (preserve_dates)
3374         {
3375           stat_status = bfd_stat_arch_elt (this_element, &buf);
3376
3377           if (stat_status != 0)
3378             non_fatal (_("internal stat error on %s"),
3379                        bfd_get_filename (this_element));
3380         }
3381
3382       l = (struct name_list *) xmalloc (sizeof (struct name_list));
3383       l->name = output_name;
3384       l->next = list;
3385       l->obfd = NULL;
3386       list = l;
3387
3388       ok_object = bfd_check_format (this_element, bfd_object);
3389       if (!ok_object)
3390         bfd_nonfatal_message (NULL, this_element, NULL,
3391                               _("Unable to recognise the format of file"));
3392
3393       /* PR binutils/3110: Cope with archives
3394          containing multiple target types.  */
3395       if (force_output_target || !ok_object)
3396         output_bfd = bfd_openw (output_name, output_target);
3397       else
3398         output_bfd = bfd_openw (output_name, bfd_get_target (this_element));
3399
3400       if (output_bfd == NULL)
3401         {
3402           bfd_nonfatal_message (output_name, NULL, NULL, NULL);
3403           status = 1;
3404           goto cleanup_and_exit;
3405         }
3406
3407       if (ok_object)
3408         {
3409           del = !copy_object (this_element, output_bfd, input_arch);
3410
3411           if (del && bfd_get_arch (this_element) == bfd_arch_unknown)
3412             /* Try again as an unknown object file.  */
3413             ok_object = FALSE;
3414           else if (!bfd_close (output_bfd))
3415             {
3416               bfd_nonfatal_message (output_name, NULL, NULL, NULL);
3417               /* Error in new object file. Don't change archive.  */
3418               status = 1;
3419             }
3420         }
3421
3422       if (!ok_object)
3423         {
3424           del = !copy_unknown_object (this_element, output_bfd);
3425           if (!bfd_close_all_done (output_bfd))
3426             {
3427               bfd_nonfatal_message (output_name, NULL, NULL, NULL);
3428               /* Error in new object file. Don't change archive.  */
3429               status = 1;
3430             }
3431         }
3432
3433       if (del)
3434         {
3435           unlink (output_name);
3436           status = 1;
3437         }
3438       else
3439         {
3440           if (preserve_dates && stat_status == 0)
3441             set_times (output_name, &buf);
3442
3443           /* Open the newly output file and attach to our list.  */
3444           output_bfd = bfd_openr (output_name, output_target);
3445
3446           l->obfd = output_bfd;
3447
3448           *ptr = output_bfd;
3449           ptr = &output_bfd->archive_next;
3450
3451           last_element = this_element;
3452
3453           this_element = bfd_openr_next_archived_file (ibfd, last_element);
3454
3455           bfd_close (last_element);
3456         }
3457     }
3458   *ptr = NULL;
3459
3460   filename = bfd_get_filename (obfd);
3461   if (!bfd_close (obfd))
3462     {
3463       status = 1;
3464       bfd_nonfatal_message (filename, NULL, NULL, NULL);
3465     }
3466
3467   filename = bfd_get_filename (ibfd);
3468   if (!bfd_close (ibfd))
3469     {
3470       status = 1;
3471       bfd_nonfatal_message (filename, NULL, NULL, NULL);
3472     }
3473
3474  cleanup_and_exit:
3475   /* Delete all the files that we opened.  */
3476   {
3477     struct name_list * next;
3478
3479     for (l = list; l != NULL; l = next)
3480       {
3481         if (l->obfd == NULL)
3482           rmdir (l->name);
3483         else
3484           {
3485             bfd_close (l->obfd);
3486             unlink (l->name);
3487           }
3488         next = l->next;
3489         free (l);
3490       }
3491   }
3492
3493   rmdir (dir);
3494 }
3495
3496 static void
3497 set_long_section_mode (bfd *output_bfd, bfd *input_bfd, enum long_section_name_handling style)
3498 {
3499   /* This is only relevant to Coff targets.  */
3500   if (bfd_get_flavour (output_bfd) == bfd_target_coff_flavour)
3501     {
3502       if (style == KEEP
3503           && bfd_get_flavour (input_bfd) == bfd_target_coff_flavour)
3504         style = bfd_coff_long_section_names (input_bfd) ? ENABLE : DISABLE;
3505       bfd_coff_set_long_section_names (output_bfd, style != DISABLE);
3506     }
3507 }
3508
3509 /* The top-level control.  */
3510
3511 static void
3512 copy_file (const char *input_filename, const char *output_filename,
3513            const char *input_target,   const char *output_target,
3514            const bfd_arch_info_type *input_arch)
3515 {
3516   bfd *ibfd;
3517   char **obj_matching;
3518   char **core_matching;
3519   off_t size = get_file_size (input_filename);
3520
3521   if (size < 1)
3522     {
3523       if (size == 0)
3524         non_fatal (_("error: the input file '%s' is empty"),
3525                    input_filename);
3526       status = 1;
3527       return;
3528     }
3529
3530   /* To allow us to do "strip *" without dying on the first
3531      non-object file, failures are nonfatal.  */
3532   ibfd = bfd_openr (input_filename, input_target);
3533   if (ibfd == NULL)
3534     {
3535       bfd_nonfatal_message (input_filename, NULL, NULL, NULL);
3536       status = 1;
3537       return;
3538     }
3539
3540   switch (do_debug_sections)
3541     {
3542     case compress:
3543     case compress_zlib:
3544     case compress_gnu_zlib:
3545     case compress_gabi_zlib:
3546       ibfd->flags |= BFD_COMPRESS;
3547       /* Don't check if input is ELF here since this information is
3548          only available after bfd_check_format_matches is called.  */
3549       if (do_debug_sections != compress_gnu_zlib)
3550         ibfd->flags |= BFD_COMPRESS_GABI;
3551       break;
3552     case decompress:
3553       ibfd->flags |= BFD_DECOMPRESS;
3554       break;
3555     default:
3556       break;
3557     }
3558
3559   switch (do_elf_stt_common)
3560     {
3561     case elf_stt_common:
3562       ibfd->flags |= BFD_CONVERT_ELF_COMMON | BFD_USE_ELF_STT_COMMON;
3563       break;
3564       break;
3565     case no_elf_stt_common:
3566       ibfd->flags |= BFD_CONVERT_ELF_COMMON;
3567       break;
3568     default:
3569       break;
3570     }
3571
3572   if (bfd_check_format (ibfd, bfd_archive))
3573     {
3574       bfd_boolean force_output_target;
3575       bfd *obfd;
3576
3577       /* bfd_get_target does not return the correct value until
3578          bfd_check_format succeeds.  */
3579       if (output_target == NULL)
3580         {
3581           output_target = bfd_get_target (ibfd);
3582           force_output_target = FALSE;
3583         }
3584       else
3585         force_output_target = TRUE;
3586
3587       obfd = bfd_openw (output_filename, output_target);
3588       if (obfd == NULL)
3589         {
3590           bfd_nonfatal_message (output_filename, NULL, NULL, NULL);
3591           status = 1;
3592           return;
3593         }
3594       /* This is a no-op on non-Coff targets.  */
3595       set_long_section_mode (obfd, ibfd, long_section_names);
3596
3597       copy_archive (ibfd, obfd, output_target, force_output_target, input_arch);
3598     }
3599   else if (bfd_check_format_matches (ibfd, bfd_object, &obj_matching))
3600     {
3601       bfd *obfd;
3602     do_copy:
3603
3604       /* bfd_get_target does not return the correct value until
3605          bfd_check_format succeeds.  */
3606       if (output_target == NULL)
3607         output_target = bfd_get_target (ibfd);
3608
3609       obfd = bfd_openw (output_filename, output_target);
3610       if (obfd == NULL)
3611         {
3612           bfd_nonfatal_message (output_filename, NULL, NULL, NULL);
3613           status = 1;
3614           return;
3615         }
3616       /* This is a no-op on non-Coff targets.  */
3617       set_long_section_mode (obfd, ibfd, long_section_names);
3618
3619       if (! copy_object (ibfd, obfd, input_arch))
3620         status = 1;
3621
3622       /* PR 17512: file: 0f15796a.
3623          If the file could not be copied it may not be in a writeable
3624          state.  So use bfd_close_all_done to avoid the possibility of
3625          writing uninitialised data into the file.  */
3626       if (! (status ? bfd_close_all_done (obfd) : bfd_close (obfd)))
3627         {
3628           status = 1;
3629           bfd_nonfatal_message (output_filename, NULL, NULL, NULL);
3630           return;
3631         }
3632
3633       if (!bfd_close (ibfd))
3634         {
3635           status = 1;
3636           bfd_nonfatal_message (input_filename, NULL, NULL, NULL);
3637           return;
3638         }
3639     }
3640   else
3641     {
3642       bfd_error_type obj_error = bfd_get_error ();
3643       bfd_error_type core_error;
3644
3645       if (bfd_check_format_matches (ibfd, bfd_core, &core_matching))
3646         {
3647           /* This probably can't happen..  */
3648           if (obj_error == bfd_error_file_ambiguously_recognized)
3649             free (obj_matching);
3650           goto do_copy;
3651         }
3652
3653       core_error = bfd_get_error ();
3654       /* Report the object error in preference to the core error.  */
3655       if (obj_error != core_error)
3656         bfd_set_error (obj_error);
3657
3658       bfd_nonfatal_message (input_filename, NULL, NULL, NULL);
3659
3660       if (obj_error == bfd_error_file_ambiguously_recognized)
3661         {
3662           list_matching_formats (obj_matching);
3663           free (obj_matching);
3664         }
3665       if (core_error == bfd_error_file_ambiguously_recognized)
3666         {
3667           list_matching_formats (core_matching);
3668           free (core_matching);
3669         }
3670
3671       status = 1;
3672     }
3673 }
3674
3675 /* Add a name to the section renaming list.  */
3676
3677 static void
3678 add_section_rename (const char * old_name, const char * new_name,
3679                     flagword flags)
3680 {
3681   section_rename * srename;
3682
3683   /* Check for conflicts first.  */
3684   for (srename = section_rename_list; srename != NULL; srename = srename->next)
3685     if (strcmp (srename->old_name, old_name) == 0)
3686       {
3687         /* Silently ignore duplicate definitions.  */
3688         if (strcmp (srename->new_name, new_name) == 0
3689             && srename->flags == flags)
3690           return;
3691
3692         fatal (_("Multiple renames of section %s"), old_name);
3693       }
3694
3695   srename = (section_rename *) xmalloc (sizeof (* srename));
3696
3697   srename->old_name = old_name;
3698   srename->new_name = new_name;
3699   srename->flags    = flags;
3700   srename->next     = section_rename_list;
3701
3702   section_rename_list = srename;
3703 }
3704
3705 /* Check the section rename list for a new name of the input section
3706    called OLD_NAME.  Returns the new name if one is found and sets
3707    RETURNED_FLAGS if non-NULL to the flags to be used for this section.  */
3708
3709 static const char *
3710 find_section_rename (const char *old_name, flagword *returned_flags)
3711 {
3712   const section_rename *srename;
3713
3714   for (srename = section_rename_list; srename != NULL; srename = srename->next)
3715     if (strcmp (srename->old_name, old_name) == 0)
3716       {
3717         if (returned_flags != NULL && srename->flags != (flagword) -1)
3718           *returned_flags = srename->flags;
3719
3720         return srename->new_name;
3721       }
3722
3723   return old_name;
3724 }
3725
3726 /* Once each of the sections is copied, we may still need to do some
3727    finalization work for private section headers.  Do that here.  */
3728
3729 static void
3730 setup_bfd_headers (bfd *ibfd, bfd *obfd)
3731 {
3732   /* Allow the BFD backend to copy any private data it understands
3733      from the input section to the output section.  */
3734   if (! bfd_copy_private_header_data (ibfd, obfd))
3735     {
3736       status = 1;
3737       bfd_nonfatal_message (NULL, ibfd, NULL,
3738                             _("error in private header data"));
3739       return;
3740     }
3741
3742   /* All went well.  */
3743   return;
3744 }
3745
3746 /* Create a section in OBFD with the same
3747    name and attributes as ISECTION in IBFD.  */
3748
3749 static void
3750 setup_section (bfd *ibfd, sec_ptr isection, void *obfdarg)
3751 {
3752   bfd *obfd = (bfd *) obfdarg;
3753   struct section_list *p;
3754   sec_ptr osection;
3755   bfd_size_type size;
3756   bfd_vma vma;
3757   bfd_vma lma;
3758   flagword flags;
3759   const char *err;
3760   const char * name;
3761   char *prefix = NULL;
3762   bfd_boolean make_nobits;
3763
3764   if (is_strip_section (ibfd, isection))
3765     return;
3766
3767   /* Get the, possibly new, name of the output section.  */
3768   name = bfd_section_name (ibfd, isection);
3769   flags = bfd_get_section_flags (ibfd, isection);
3770   name = find_section_rename (name, &flags);
3771
3772   /* Prefix sections.  */
3773   if ((prefix_alloc_sections_string)
3774       && (bfd_get_section_flags (ibfd, isection) & SEC_ALLOC))
3775     prefix = prefix_alloc_sections_string;
3776   else if (prefix_sections_string)
3777     prefix = prefix_sections_string;
3778
3779   if (prefix)
3780     {
3781       char *n;
3782
3783       n = (char *) xmalloc (strlen (prefix) + strlen (name) + 1);
3784       strcpy (n, prefix);
3785       strcat (n, name);
3786       name = n;
3787     }
3788
3789   make_nobits = FALSE;
3790
3791   p = find_section_list (bfd_section_name (ibfd, isection), FALSE,
3792                          SECTION_CONTEXT_SET_FLAGS);
3793   if (p != NULL)
3794     flags = p->flags | (flags & (SEC_HAS_CONTENTS | SEC_RELOC));
3795   else if (strip_symbols == STRIP_NONDEBUG
3796            && (flags & (SEC_ALLOC | SEC_GROUP)) != 0
3797            && !is_nondebug_keep_contents_section (ibfd, isection))
3798     {
3799       flags &= ~(SEC_HAS_CONTENTS | SEC_LOAD | SEC_GROUP);
3800       if (obfd->xvec->flavour == bfd_target_elf_flavour)
3801         {
3802           make_nobits = TRUE;
3803
3804           /* Twiddle the input section flags so that it seems to
3805              elf.c:copy_private_bfd_data that section flags have not
3806              changed between input and output sections.  This hack
3807              prevents wholesale rewriting of the program headers.  */
3808           isection->flags &= ~(SEC_HAS_CONTENTS | SEC_LOAD | SEC_GROUP);
3809         }
3810     }
3811
3812   osection = bfd_make_section_anyway_with_flags (obfd, name, flags);
3813
3814   if (osection == NULL)
3815     {
3816       err = _("failed to create output section");
3817       goto loser;
3818     }
3819
3820   if (make_nobits)
3821     elf_section_type (osection) = SHT_NOBITS;
3822
3823   size = bfd_section_size (ibfd, isection);
3824   size = bfd_convert_section_size (ibfd, isection, obfd, size);
3825   if (copy_byte >= 0)
3826     size = (size + interleave - 1) / interleave * copy_width;
3827   else if (extract_symbol)
3828     size = 0;
3829   if (! bfd_set_section_size (obfd, osection, size))
3830     {
3831       err = _("failed to set size");
3832       goto loser;
3833     }
3834
3835   vma = bfd_section_vma (ibfd, isection);
3836   p = find_section_list (bfd_section_name (ibfd, isection), FALSE,
3837                          SECTION_CONTEXT_ALTER_VMA | SECTION_CONTEXT_SET_VMA);
3838   if (p != NULL)
3839     {
3840       if (p->context & SECTION_CONTEXT_SET_VMA)
3841         vma = p->vma_val;
3842       else
3843         vma += p->vma_val;
3844     }
3845   else
3846     vma += change_section_address;
3847
3848   if (! bfd_set_section_vma (obfd, osection, vma))
3849     {
3850       err = _("failed to set vma");
3851       goto loser;
3852     }
3853
3854   lma = isection->lma;
3855   p = find_section_list (bfd_section_name (ibfd, isection), FALSE,
3856                          SECTION_CONTEXT_ALTER_LMA | SECTION_CONTEXT_SET_LMA);
3857   if (p != NULL)
3858     {
3859       if (p->context & SECTION_CONTEXT_ALTER_LMA)
3860         lma += p->lma_val;
3861       else
3862         lma = p->lma_val;
3863     }
3864   else
3865     lma += change_section_address;
3866
3867   osection->lma = lma;
3868
3869   /* FIXME: This is probably not enough.  If we change the LMA we
3870      may have to recompute the header for the file as well.  */
3871   if (!bfd_set_section_alignment (obfd,
3872                                   osection,
3873                                   bfd_section_alignment (ibfd, isection)))
3874     {
3875       err = _("failed to set alignment");
3876       goto loser;
3877     }
3878
3879   /* Copy merge entity size.  */
3880   osection->entsize = isection->entsize;
3881
3882   /* Copy compress status.  */
3883   osection->compress_status = isection->compress_status;
3884
3885   /* This used to be mangle_section; we do here to avoid using
3886      bfd_get_section_by_name since some formats allow multiple
3887      sections with the same name.  */
3888   isection->output_section = osection;
3889   isection->output_offset = 0;
3890
3891   if ((isection->flags & SEC_GROUP) != 0)
3892     {
3893       asymbol *gsym = group_signature (isection);
3894
3895       if (gsym != NULL)
3896         {
3897           gsym->flags |= BSF_KEEP;
3898           if (ibfd->xvec->flavour == bfd_target_elf_flavour)
3899             elf_group_id (isection) = gsym;
3900         }
3901     }
3902
3903   /* Allow the BFD backend to copy any private data it understands
3904      from the input section to the output section.  */
3905   if (!bfd_copy_private_section_data (ibfd, isection, obfd, osection))
3906     {
3907       err = _("failed to copy private data");
3908       goto loser;
3909     }
3910
3911   /* All went well.  */
3912   return;
3913
3914  loser:
3915   status = 1;
3916   bfd_nonfatal_message (NULL, obfd, osection, err);
3917 }
3918
3919 /* Return TRUE if input section ISECTION should be skipped.  */
3920
3921 static bfd_boolean
3922 skip_section (bfd *ibfd, sec_ptr isection, bfd_boolean skip_copy)
3923 {
3924   sec_ptr osection;
3925   bfd_size_type size;
3926   flagword flags;
3927
3928   /* If we have already failed earlier on,
3929      do not keep on generating complaints now.  */
3930   if (status != 0)
3931     return TRUE;
3932
3933   if (extract_symbol)
3934     return TRUE;
3935
3936   if (is_strip_section (ibfd, isection))
3937     return TRUE;
3938
3939   if (is_update_section (ibfd, isection))
3940     return TRUE;
3941
3942   /* When merging a note section we skip the copying of the contents,
3943      but not the copying of the relocs associated with the contents.  */
3944   if (skip_copy && is_merged_note_section (ibfd, isection))
3945     return TRUE;
3946
3947   flags = bfd_get_section_flags (ibfd, isection);
3948   if ((flags & SEC_GROUP) != 0)
3949     return TRUE;
3950
3951   osection = isection->output_section;
3952   size = bfd_get_section_size (isection);
3953
3954   if (size == 0 || osection == 0)
3955     return TRUE;
3956
3957   return FALSE;
3958 }
3959
3960 /* Add section SECTION_PATTERN to the list of sections that will have their
3961    relocations removed.  */
3962
3963 static void
3964 handle_remove_relocations_option (const char *section_pattern)
3965 {
3966   find_section_list (section_pattern, TRUE, SECTION_CONTEXT_REMOVE_RELOCS);
3967 }
3968
3969 /* Return TRUE if ISECTION from IBFD should have its relocations removed,
3970    otherwise return FALSE.  If the user has requested that relocations be
3971    removed from a section that does not have relocations then this
3972    function will still return TRUE.  */
3973
3974 static bfd_boolean
3975 discard_relocations (bfd *ibfd ATTRIBUTE_UNUSED, asection *isection)
3976 {
3977   return (find_section_list (bfd_section_name (ibfd, isection), FALSE,
3978                              SECTION_CONTEXT_REMOVE_RELOCS) != NULL);
3979 }
3980
3981 /* Wrapper for dealing with --remove-section (-R) command line arguments.
3982    A special case is detected here, if the user asks to remove a relocation
3983    section (one starting with ".rela" or ".rel") then this removal must
3984    be done using a different technique in a relocatable object.  */
3985
3986 static void
3987 handle_remove_section_option (const char *section_pattern)
3988 {
3989   find_section_list (section_pattern, TRUE, SECTION_CONTEXT_REMOVE);
3990   if (strncmp (section_pattern, ".rel", 4) == 0)
3991     {
3992       section_pattern += 4;
3993       if (*section_pattern == 'a')
3994         section_pattern++;
3995       if (*section_pattern)
3996         handle_remove_relocations_option (section_pattern);
3997     }
3998   sections_removed = TRUE;
3999 }
4000
4001 /* Copy relocations in input section ISECTION of IBFD to an output
4002    section with the same name in OBFDARG.  If stripping then don't
4003    copy any relocation info.  */
4004
4005 static void
4006 copy_relocations_in_section (bfd *ibfd, sec_ptr isection, void *obfdarg)
4007 {
4008   bfd *obfd = (bfd *) obfdarg;
4009   long relsize;
4010   arelent **relpp;
4011   long relcount;
4012   sec_ptr osection;
4013
4014  if (skip_section (ibfd, isection, FALSE))
4015     return;
4016
4017   osection = isection->output_section;
4018
4019   /* Core files and DWO files do not need to be relocated.  */
4020   if (bfd_get_format (obfd) == bfd_core
4021       || strip_symbols == STRIP_NONDWO
4022       || discard_relocations (ibfd, isection))
4023     relsize = 0;
4024   else
4025     {
4026       relsize = bfd_get_reloc_upper_bound (ibfd, isection);
4027
4028       if (relsize < 0)
4029         {
4030           /* Do not complain if the target does not support relocations.  */
4031           if (relsize == -1 && bfd_get_error () == bfd_error_invalid_operation)
4032             relsize = 0;
4033           else
4034             {
4035               status = 1;
4036               bfd_nonfatal_message (NULL, ibfd, isection, NULL);
4037               return;
4038             }
4039         }
4040     }
4041
4042   if (relsize == 0)
4043     {
4044       bfd_set_reloc (obfd, osection, NULL, 0);
4045       osection->flags &= ~SEC_RELOC;
4046     }
4047   else
4048     {
4049       if (isection->orelocation != NULL)
4050         {
4051           /* Some other function has already set up the output relocs
4052              for us, so scan those instead of the default relocs.  */
4053           relcount = isection->reloc_count;
4054           relpp = isection->orelocation;
4055         }
4056       else
4057         {
4058           relpp = (arelent **) xmalloc (relsize);
4059           relcount = bfd_canonicalize_reloc (ibfd, isection, relpp, isympp);
4060           if (relcount < 0)
4061             {
4062               status = 1;
4063               bfd_nonfatal_message (NULL, ibfd, isection,
4064                                     _("relocation count is negative"));
4065               return;
4066             }
4067         }
4068
4069       if (strip_symbols == STRIP_ALL)
4070         {
4071           /* Remove relocations which are not in
4072              keep_strip_specific_list.  */
4073           arelent **temp_relpp;
4074           long temp_relcount = 0;
4075           long i;
4076
4077           temp_relpp = (arelent **) xmalloc (relsize);
4078           for (i = 0; i < relcount; i++)
4079             {
4080               /* PR 17512: file: 9e907e0c.  */
4081               if (relpp[i]->sym_ptr_ptr
4082                   /* PR 20096 */
4083                   && * relpp[i]->sym_ptr_ptr)
4084                 if (is_specified_symbol (bfd_asymbol_name (*relpp[i]->sym_ptr_ptr),
4085                                          keep_specific_htab))
4086                   temp_relpp [temp_relcount++] = relpp [i];
4087             }
4088           relcount = temp_relcount;
4089           if (isection->orelocation == NULL)
4090             free (relpp);
4091           relpp = temp_relpp;
4092         }
4093
4094       bfd_set_reloc (obfd, osection, relcount == 0 ? NULL : relpp, relcount);
4095       if (relcount == 0)
4096         {
4097           osection->flags &= ~SEC_RELOC;
4098           free (relpp);
4099         }
4100     }
4101 }
4102
4103 /* Copy the data of input section ISECTION of IBFD
4104    to an output section with the same name in OBFD.  */
4105
4106 static void
4107 copy_section (bfd *ibfd, sec_ptr isection, void *obfdarg)
4108 {
4109   bfd *obfd = (bfd *) obfdarg;
4110   struct section_list *p;
4111   sec_ptr osection;
4112   bfd_size_type size;
4113
4114   if (skip_section (ibfd, isection, TRUE))
4115     return;
4116
4117   osection = isection->output_section;
4118   /* The output SHF_COMPRESSED section size is different from input if
4119      ELF classes of input and output aren't the same.  We can't use
4120      the output section size since --interleave will shrink the output
4121      section.   Size will be updated if the section is converted.   */
4122   size = bfd_get_section_size (isection);
4123
4124   if (bfd_get_section_flags (ibfd, isection) & SEC_HAS_CONTENTS
4125       && bfd_get_section_flags (obfd, osection) & SEC_HAS_CONTENTS)
4126     {
4127       bfd_byte *memhunk = NULL;
4128
4129       if (!bfd_get_full_section_contents (ibfd, isection, &memhunk)
4130           || !bfd_convert_section_contents (ibfd, isection, obfd,
4131                                             &memhunk, &size))
4132         {
4133           status = 1;
4134           bfd_nonfatal_message (NULL, ibfd, isection, NULL);
4135           free (memhunk);
4136           return;
4137         }
4138
4139       if (reverse_bytes)
4140         {
4141           /* We don't handle leftover bytes (too many possible behaviors,
4142              and we don't know what the user wants).  The section length
4143              must be a multiple of the number of bytes to swap.  */
4144           if ((size % reverse_bytes) == 0)
4145             {
4146               unsigned long i, j;
4147               bfd_byte b;
4148
4149               for (i = 0; i < size; i += reverse_bytes)
4150                 for (j = 0; j < (unsigned long)(reverse_bytes / 2); j++)
4151                   {
4152                     bfd_byte *m = (bfd_byte *) memhunk;
4153
4154                     b = m[i + j];
4155                     m[i + j] = m[(i + reverse_bytes) - (j + 1)];
4156                     m[(i + reverse_bytes) - (j + 1)] = b;
4157                   }
4158             }
4159           else
4160             /* User must pad the section up in order to do this.  */
4161             fatal (_("cannot reverse bytes: length of section %s must be evenly divisible by %d"),
4162                    bfd_section_name (ibfd, isection), reverse_bytes);
4163         }
4164
4165       if (copy_byte >= 0)
4166         {
4167           /* Keep only every `copy_byte'th byte in MEMHUNK.  */
4168           char *from = (char *) memhunk + copy_byte;
4169           char *to = (char *) memhunk;
4170           char *end = (char *) memhunk + size;
4171           int i;
4172
4173           /* If the section address is not exactly divisible by the interleave,
4174              then we must bias the from address.  If the copy_byte is less than
4175              the bias, then we must skip forward one interleave, and increment
4176              the final lma.  */
4177           int extra = isection->lma % interleave;
4178           from -= extra;
4179           if (copy_byte < extra)
4180             from += interleave;
4181
4182           for (; from < end; from += interleave)
4183             for (i = 0; i < copy_width; i++)
4184               {
4185                 if (&from[i] >= end)
4186                   break;
4187                 *to++ = from[i];
4188               }
4189
4190           size = (size + interleave - 1 - copy_byte) / interleave * copy_width;
4191           osection->lma /= interleave;
4192           if (copy_byte < extra)
4193             osection->lma++;
4194         }
4195
4196       if (!bfd_set_section_contents (obfd, osection, memhunk, 0, size))
4197         {
4198           status = 1;
4199           bfd_nonfatal_message (NULL, obfd, osection, NULL);
4200           free (memhunk);
4201           return;
4202         }
4203       free (memhunk);
4204     }
4205   else if ((p = find_section_list (bfd_get_section_name (ibfd, isection),
4206                                    FALSE, SECTION_CONTEXT_SET_FLAGS)) != NULL
4207            && (p->flags & SEC_HAS_CONTENTS) != 0)
4208     {
4209       void *memhunk = xmalloc (size);
4210
4211       /* We don't permit the user to turn off the SEC_HAS_CONTENTS
4212          flag--they can just remove the section entirely and add it
4213          back again.  However, we do permit them to turn on the
4214          SEC_HAS_CONTENTS flag, and take it to mean that the section
4215          contents should be zeroed out.  */
4216
4217       memset (memhunk, 0, size);
4218       if (! bfd_set_section_contents (obfd, osection, memhunk, 0, size))
4219         {
4220           status = 1;
4221           bfd_nonfatal_message (NULL, obfd, osection, NULL);
4222           free (memhunk);
4223           return;
4224         }
4225       free (memhunk);
4226     }
4227 }
4228
4229 /* Get all the sections.  This is used when --gap-fill or --pad-to is
4230    used.  */
4231
4232 static void
4233 get_sections (bfd *obfd ATTRIBUTE_UNUSED, asection *osection, void *secppparg)
4234 {
4235   asection ***secppp = (asection ***) secppparg;
4236
4237   **secppp = osection;
4238   ++(*secppp);
4239 }
4240
4241 /* Sort sections by VMA.  This is called via qsort, and is used when
4242    --gap-fill or --pad-to is used.  We force non loadable or empty
4243    sections to the front, where they are easier to ignore.  */
4244
4245 static int
4246 compare_section_lma (const void *arg1, const void *arg2)
4247 {
4248   const asection *const *sec1 = (const asection * const *) arg1;
4249   const asection *const *sec2 = (const asection * const *) arg2;
4250   flagword flags1, flags2;
4251
4252   /* Sort non loadable sections to the front.  */
4253   flags1 = (*sec1)->flags;
4254   flags2 = (*sec2)->flags;
4255   if ((flags1 & SEC_HAS_CONTENTS) == 0
4256       || (flags1 & SEC_LOAD) == 0)
4257     {
4258       if ((flags2 & SEC_HAS_CONTENTS) != 0
4259           && (flags2 & SEC_LOAD) != 0)
4260         return -1;
4261     }
4262   else
4263     {
4264       if ((flags2 & SEC_HAS_CONTENTS) == 0
4265           || (flags2 & SEC_LOAD) == 0)
4266         return 1;
4267     }
4268
4269   /* Sort sections by LMA.  */
4270   if ((*sec1)->lma > (*sec2)->lma)
4271     return 1;
4272   else if ((*sec1)->lma < (*sec2)->lma)
4273     return -1;
4274
4275   /* Sort sections with the same LMA by size.  */
4276   if (bfd_get_section_size (*sec1) > bfd_get_section_size (*sec2))
4277     return 1;
4278   else if (bfd_get_section_size (*sec1) < bfd_get_section_size (*sec2))
4279     return -1;
4280
4281   return 0;
4282 }
4283
4284 /* Mark all the symbols which will be used in output relocations with
4285    the BSF_KEEP flag so that those symbols will not be stripped.
4286
4287    Ignore relocations which will not appear in the output file.  */
4288
4289 static void
4290 mark_symbols_used_in_relocations (bfd *ibfd, sec_ptr isection, void *symbolsarg)
4291 {
4292   asymbol **symbols = (asymbol **) symbolsarg;
4293   long relsize;
4294   arelent **relpp;
4295   long relcount, i;
4296
4297   /* Ignore an input section with no corresponding output section.  */
4298   if (isection->output_section == NULL)
4299     return;
4300
4301   relsize = bfd_get_reloc_upper_bound (ibfd, isection);
4302   if (relsize < 0)
4303     {
4304       /* Do not complain if the target does not support relocations.  */
4305       if (relsize == -1 && bfd_get_error () == bfd_error_invalid_operation)
4306         return;
4307       bfd_fatal (bfd_get_filename (ibfd));
4308     }
4309
4310   if (relsize == 0)
4311     return;
4312
4313   relpp = (arelent **) xmalloc (relsize);
4314   relcount = bfd_canonicalize_reloc (ibfd, isection, relpp, symbols);
4315   if (relcount < 0)
4316     bfd_fatal (bfd_get_filename (ibfd));
4317
4318   /* Examine each symbol used in a relocation.  If it's not one of the
4319      special bfd section symbols, then mark it with BSF_KEEP.  */
4320   for (i = 0; i < relcount; i++)
4321     {
4322       /* See PRs 20923 and 20930 for reproducers for the NULL tests.  */
4323       if (relpp[i]->sym_ptr_ptr != NULL
4324           && * relpp[i]->sym_ptr_ptr != NULL
4325           && *relpp[i]->sym_ptr_ptr != bfd_com_section_ptr->symbol
4326           && *relpp[i]->sym_ptr_ptr != bfd_abs_section_ptr->symbol
4327           && *relpp[i]->sym_ptr_ptr != bfd_und_section_ptr->symbol)
4328         (*relpp[i]->sym_ptr_ptr)->flags |= BSF_KEEP;
4329     }
4330
4331   if (relpp != NULL)
4332     free (relpp);
4333 }
4334
4335 /* Write out debugging information.  */
4336
4337 static bfd_boolean
4338 write_debugging_info (bfd *obfd, void *dhandle,
4339                       long *symcountp ATTRIBUTE_UNUSED,
4340                       asymbol ***symppp ATTRIBUTE_UNUSED)
4341 {
4342   if (bfd_get_flavour (obfd) == bfd_target_coff_flavour
4343       || bfd_get_flavour (obfd) == bfd_target_elf_flavour)
4344     {
4345       bfd_byte *syms, *strings = NULL;
4346       bfd_size_type symsize, stringsize;
4347       asection *stabsec, *stabstrsec;
4348       flagword flags;
4349
4350       if (! write_stabs_in_sections_debugging_info (obfd, dhandle, &syms,
4351                                                     &symsize, &strings,
4352                                                     &stringsize))
4353         return FALSE;
4354
4355       flags = SEC_HAS_CONTENTS | SEC_READONLY | SEC_DEBUGGING;
4356       stabsec = bfd_make_section_with_flags (obfd, ".stab", flags);
4357       stabstrsec = bfd_make_section_with_flags (obfd, ".stabstr", flags);
4358       if (stabsec == NULL
4359           || stabstrsec == NULL
4360           || ! bfd_set_section_size (obfd, stabsec, symsize)
4361           || ! bfd_set_section_size (obfd, stabstrsec, stringsize)
4362           || ! bfd_set_section_alignment (obfd, stabsec, 2)
4363           || ! bfd_set_section_alignment (obfd, stabstrsec, 0))
4364         {
4365           bfd_nonfatal_message (NULL, obfd, NULL,
4366                                 _("can't create debugging section"));
4367           free (strings);
4368           return FALSE;
4369         }
4370
4371       /* We can get away with setting the section contents now because
4372          the next thing the caller is going to do is copy over the
4373          real sections.  We may someday have to split the contents
4374          setting out of this function.  */
4375       if (! bfd_set_section_contents (obfd, stabsec, syms, 0, symsize)
4376           || ! bfd_set_section_contents (obfd, stabstrsec, strings, 0,
4377                                          stringsize))
4378         {
4379           bfd_nonfatal_message (NULL, obfd, NULL,
4380                                 _("can't set debugging section contents"));
4381           free (strings);
4382           return FALSE;
4383         }
4384
4385       return TRUE;
4386     }
4387
4388   bfd_nonfatal_message (NULL, obfd, NULL,
4389                         _("don't know how to write debugging information for %s"),
4390                         bfd_get_target (obfd));
4391   return FALSE;
4392 }
4393
4394 /* If neither -D nor -U was specified explicitly,
4395    then use the configured default.  */
4396 static void
4397 default_deterministic (void)
4398 {
4399   if (deterministic < 0)
4400     deterministic = DEFAULT_AR_DETERMINISTIC;
4401 }
4402
4403 static int
4404 strip_main (int argc, char *argv[])
4405 {
4406   char *input_target = NULL;
4407   char *output_target = NULL;
4408   bfd_boolean show_version = FALSE;
4409   bfd_boolean formats_info = FALSE;
4410   int c;
4411   int i;
4412   char *output_file = NULL;
4413
4414   merge_notes = TRUE;
4415
4416   while ((c = getopt_long (argc, argv, "I:O:F:K:MN:R:o:sSpdgxXHhVvwDU",
4417                            strip_options, (int *) 0)) != EOF)
4418     {
4419       switch (c)
4420         {
4421         case 'I':
4422           input_target = optarg;
4423           break;
4424         case 'O':
4425           output_target = optarg;
4426           break;
4427         case 'F':
4428           input_target = output_target = optarg;
4429           break;
4430         case 'R':
4431           handle_remove_section_option (optarg);
4432           break;
4433         case OPTION_REMOVE_RELOCS:
4434           handle_remove_relocations_option (optarg);
4435           break;
4436         case 's':
4437           strip_symbols = STRIP_ALL;
4438           break;
4439         case 'S':
4440         case 'g':
4441         case 'd':       /* Historic BSD alias for -g.  Used by early NetBSD.  */
4442           strip_symbols = STRIP_DEBUG;
4443           break;
4444         case OPTION_STRIP_DWO:
4445           strip_symbols = STRIP_DWO;
4446           break;
4447         case OPTION_STRIP_UNNEEDED:
4448           strip_symbols = STRIP_UNNEEDED;
4449           break;
4450         case 'K':
4451           add_specific_symbol (optarg, keep_specific_htab);
4452           break;
4453         case 'M':
4454           merge_notes = TRUE;
4455           break;
4456         case OPTION_NO_MERGE_NOTES:
4457           merge_notes = FALSE;
4458           break;
4459         case 'N':
4460           add_specific_symbol (optarg, strip_specific_htab);
4461           break;
4462         case 'o':
4463           output_file = optarg;
4464           break;
4465         case 'p':
4466           preserve_dates = TRUE;
4467           break;
4468         case 'D':
4469           deterministic = TRUE;
4470           break;
4471         case 'U':
4472           deterministic = FALSE;
4473           break;
4474         case 'x':
4475           discard_locals = LOCALS_ALL;
4476           break;
4477         case 'X':
4478           discard_locals = LOCALS_START_L;
4479           break;
4480         case 'v':
4481           verbose = TRUE;
4482           break;
4483         case 'V':
4484           show_version = TRUE;
4485           break;
4486         case OPTION_FORMATS_INFO:
4487           formats_info = TRUE;
4488           break;
4489         case OPTION_ONLY_KEEP_DEBUG:
4490           strip_symbols = STRIP_NONDEBUG;
4491           break;
4492         case OPTION_KEEP_FILE_SYMBOLS:
4493           keep_file_symbols = 1;
4494           break;
4495         case 0:
4496           /* We've been given a long option.  */
4497           break;
4498         case 'w':
4499           wildcard = TRUE;
4500           break;
4501         case 'H':
4502         case 'h':
4503           strip_usage (stdout, 0);
4504         default:
4505           strip_usage (stderr, 1);
4506         }
4507     }
4508
4509   if (formats_info)
4510     {
4511       display_info ();
4512       return 0;
4513     }
4514
4515   if (show_version)
4516     print_version ("strip");
4517
4518   default_deterministic ();
4519
4520   /* Default is to strip all symbols.  */
4521   if (strip_symbols == STRIP_UNDEF
4522       && discard_locals == LOCALS_UNDEF
4523       && htab_elements (strip_specific_htab) == 0)
4524     strip_symbols = STRIP_ALL;
4525
4526   if (output_target == NULL)
4527     output_target = input_target;
4528
4529   i = optind;
4530   if (i == argc
4531       || (output_file != NULL && (i + 1) < argc))
4532     strip_usage (stderr, 1);
4533
4534   for (; i < argc; i++)
4535     {
4536       int hold_status = status;
4537       struct stat statbuf;
4538       char *tmpname;
4539
4540       if (get_file_size (argv[i]) < 1)
4541         {
4542           status = 1;
4543           continue;
4544         }
4545
4546       if (preserve_dates)
4547         /* No need to check the return value of stat().
4548            It has already been checked in get_file_size().  */
4549         stat (argv[i], &statbuf);
4550
4551       if (output_file == NULL
4552           || filename_cmp (argv[i], output_file) == 0)
4553         tmpname = make_tempname (argv[i]);
4554       else
4555         tmpname = output_file;
4556
4557       if (tmpname == NULL)
4558         {
4559           bfd_nonfatal_message (argv[i], NULL, NULL,
4560                                 _("could not create temporary file to hold stripped copy"));
4561           status = 1;
4562           continue;
4563         }
4564
4565       status = 0;
4566       copy_file (argv[i], tmpname, input_target, output_target, NULL);
4567       if (status == 0)
4568         {
4569           if (preserve_dates)
4570             set_times (tmpname, &statbuf);
4571           if (output_file != tmpname)
4572             status = (smart_rename (tmpname,
4573                                     output_file ? output_file : argv[i],
4574                                     preserve_dates) != 0);
4575           if (status == 0)
4576             status = hold_status;
4577         }
4578       else
4579         unlink_if_ordinary (tmpname);
4580       if (output_file != tmpname)
4581         free (tmpname);
4582     }
4583
4584   return status;
4585 }
4586
4587 /* Set up PE subsystem.  */
4588
4589 static void
4590 set_pe_subsystem (const char *s)
4591 {
4592   const char *version, *subsystem;
4593   size_t i;
4594   static const struct
4595     {
4596       const char *name;
4597       const char set_def;
4598       const short value;
4599     }
4600   v[] =
4601     {
4602       { "native", 0, IMAGE_SUBSYSTEM_NATIVE },
4603       { "windows", 0, IMAGE_SUBSYSTEM_WINDOWS_GUI },
4604       { "console", 0, IMAGE_SUBSYSTEM_WINDOWS_CUI },
4605       { "posix", 0, IMAGE_SUBSYSTEM_POSIX_CUI },
4606       { "wince", 0, IMAGE_SUBSYSTEM_WINDOWS_CE_GUI },
4607       { "efi-app", 1, IMAGE_SUBSYSTEM_EFI_APPLICATION },
4608       { "efi-bsd", 1, IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER },
4609       { "efi-rtd", 1, IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER },
4610       { "sal-rtd", 1, IMAGE_SUBSYSTEM_SAL_RUNTIME_DRIVER },
4611       { "xbox", 0, IMAGE_SUBSYSTEM_XBOX }
4612     };
4613   short value;
4614   char *copy;
4615   int set_def = -1;
4616
4617   /* Check for the presence of a version number.  */
4618   version = strchr (s, ':');
4619   if (version == NULL)
4620     subsystem = s;
4621   else
4622     {
4623       int len = version - s;
4624       copy = xstrdup (s);
4625       subsystem = copy;
4626       copy[len] = '\0';
4627       version = copy + 1 + len;
4628       pe_major_subsystem_version = strtoul (version, &copy, 0);
4629       if (*copy == '.')
4630         pe_minor_subsystem_version = strtoul (copy + 1, &copy, 0);
4631       if (*copy != '\0')
4632         non_fatal (_("%s: bad version in PE subsystem"), s);
4633     }
4634
4635   /* Check for numeric subsystem.  */
4636   value = (short) strtol (subsystem, &copy, 0);
4637   if (*copy == '\0')
4638     {
4639       for (i = 0; i < ARRAY_SIZE (v); i++)
4640         if (v[i].value == value)
4641           {
4642             pe_subsystem = value;
4643             set_def = v[i].set_def;
4644             break;
4645           }
4646     }
4647   else
4648     {
4649       /* Search for subsystem by name.  */
4650       for (i = 0; i < ARRAY_SIZE (v); i++)
4651         if (strcmp (subsystem, v[i].name) == 0)
4652           {
4653             pe_subsystem = v[i].value;
4654             set_def = v[i].set_def;
4655             break;
4656           }
4657     }
4658
4659   switch (set_def)
4660     {
4661     case -1:
4662       fatal (_("unknown PE subsystem: %s"), s);
4663       break;
4664     case 0:
4665       break;
4666     default:
4667       if (pe_file_alignment == (bfd_vma) -1)
4668         pe_file_alignment = PE_DEF_FILE_ALIGNMENT;
4669       if (pe_section_alignment == (bfd_vma) -1)
4670         pe_section_alignment = PE_DEF_SECTION_ALIGNMENT;
4671       break;
4672     }
4673   if (s != subsystem)
4674     free ((char *) subsystem);
4675 }
4676
4677 /* Convert EFI target to PEI target.  */
4678
4679 static void
4680 convert_efi_target (char *efi)
4681 {
4682   efi[0] = 'p';
4683   efi[1] = 'e';
4684   efi[2] = 'i';
4685
4686   if (strcmp (efi + 4, "ia32") == 0)
4687     {
4688       /* Change ia32 to i386.  */
4689       efi[5]= '3';
4690       efi[6]= '8';
4691       efi[7]= '6';
4692     }
4693   else if (strcmp (efi + 4, "x86_64") == 0)
4694     {
4695       /* Change x86_64 to x86-64.  */
4696       efi[7] = '-';
4697     }
4698 }
4699
4700 /* Allocate and return a pointer to a struct section_add, initializing the
4701    structure using ARG, a string in the format "sectionname=filename".
4702    The returned structure will have its next pointer set to NEXT.  The
4703    OPTION field is the name of the command line option currently being
4704    parsed, and is only used if an error needs to be reported.  */
4705
4706 static struct section_add *
4707 init_section_add (const char *arg,
4708                   struct section_add *next,
4709                   const char *option)
4710 {
4711   struct section_add *pa;
4712   const char *s;
4713
4714   s = strchr (arg, '=');
4715   if (s == NULL)
4716     fatal (_("bad format for %s"), option);
4717
4718   pa = (struct section_add *) xmalloc (sizeof (struct section_add));
4719   pa->name = xstrndup (arg, s - arg);
4720   pa->filename = s + 1;
4721   pa->next = next;
4722   pa->contents = NULL;
4723   pa->size = 0;
4724
4725   return pa;
4726 }
4727
4728 /* Load the file specified in PA, allocating memory to hold the file
4729    contents, and store a pointer to the allocated memory in the contents
4730    field of PA.  The size field of PA is also updated.  All errors call
4731    FATAL.  */
4732
4733 static void
4734 section_add_load_file (struct section_add *pa)
4735 {
4736   size_t off, alloc;
4737   FILE *f;
4738
4739   /* We don't use get_file_size so that we can do
4740      --add-section .note.GNU_stack=/dev/null
4741      get_file_size doesn't work on /dev/null.  */
4742
4743   f = fopen (pa->filename, FOPEN_RB);
4744   if (f == NULL)
4745     fatal (_("cannot open: %s: %s"),
4746            pa->filename, strerror (errno));
4747
4748   off = 0;
4749   alloc = 4096;
4750   pa->contents = (bfd_byte *) xmalloc (alloc);
4751   while (!feof (f))
4752     {
4753       off_t got;
4754
4755       if (off == alloc)
4756         {
4757           alloc <<= 1;
4758           pa->contents = (bfd_byte *) xrealloc (pa->contents, alloc);
4759         }
4760
4761       got = fread (pa->contents + off, 1, alloc - off, f);
4762       if (ferror (f))
4763         fatal (_("%s: fread failed"), pa->filename);
4764
4765       off += got;
4766     }
4767
4768   pa->size = off;
4769
4770   fclose (f);
4771 }
4772
4773 static int
4774 copy_main (int argc, char *argv[])
4775 {
4776   char *input_filename = NULL;
4777   char *output_filename = NULL;
4778   char *tmpname;
4779   char *input_target = NULL;
4780   char *output_target = NULL;
4781   bfd_boolean show_version = FALSE;
4782   bfd_boolean change_warn = TRUE;
4783   bfd_boolean formats_info = FALSE;
4784   bfd_boolean use_globalize = FALSE;
4785   bfd_boolean use_keep_global = FALSE;
4786   int c;
4787   struct stat statbuf;
4788   const bfd_arch_info_type *input_arch = NULL;
4789
4790   while ((c = getopt_long (argc, argv, "b:B:i:I:j:K:MN:s:O:d:F:L:G:R:SpgxXHhVvW:wDU",
4791                            copy_options, (int *) 0)) != EOF)
4792     {
4793       switch (c)
4794         {
4795         case 'b':
4796           copy_byte = atoi (optarg);
4797           if (copy_byte < 0)
4798             fatal (_("byte number must be non-negative"));
4799           break;
4800
4801         case 'B':
4802           input_arch = bfd_scan_arch (optarg);
4803           if (input_arch == NULL)
4804             fatal (_("architecture %s unknown"), optarg);
4805           break;
4806
4807         case 'i':
4808           if (optarg)
4809             {
4810               interleave = atoi (optarg);
4811               if (interleave < 1)
4812                 fatal (_("interleave must be positive"));
4813             }
4814           else
4815             interleave = 4;
4816           break;
4817
4818         case OPTION_INTERLEAVE_WIDTH:
4819           copy_width = atoi (optarg);
4820           if (copy_width < 1)
4821             fatal(_("interleave width must be positive"));
4822           break;
4823
4824         case 'I':
4825         case 's':               /* "source" - 'I' is preferred */
4826           input_target = optarg;
4827           break;
4828
4829         case 'O':
4830         case 'd':               /* "destination" - 'O' is preferred */
4831           output_target = optarg;
4832           break;
4833
4834         case 'F':
4835           input_target = output_target = optarg;
4836           break;
4837
4838         case 'j':
4839           find_section_list (optarg, TRUE, SECTION_CONTEXT_COPY);
4840           sections_copied = TRUE;
4841           break;
4842
4843         case 'R':
4844           handle_remove_section_option (optarg);
4845           break;
4846
4847         case OPTION_REMOVE_RELOCS:
4848           handle_remove_relocations_option (optarg);
4849           break;
4850
4851         case 'S':
4852           strip_symbols = STRIP_ALL;
4853           break;
4854
4855         case 'g':
4856           strip_symbols = STRIP_DEBUG;
4857           break;
4858
4859         case OPTION_STRIP_DWO:
4860           strip_symbols = STRIP_DWO;
4861           break;
4862
4863         case OPTION_STRIP_UNNEEDED:
4864           strip_symbols = STRIP_UNNEEDED;
4865           break;
4866
4867         case OPTION_ONLY_KEEP_DEBUG:
4868           strip_symbols = STRIP_NONDEBUG;
4869           break;
4870
4871         case OPTION_KEEP_FILE_SYMBOLS:
4872           keep_file_symbols = 1;
4873           break;
4874
4875         case OPTION_ADD_GNU_DEBUGLINK:
4876           long_section_names = ENABLE ;
4877           gnu_debuglink_filename = optarg;
4878           break;
4879
4880         case 'K':
4881           add_specific_symbol (optarg, keep_specific_htab);
4882           break;
4883
4884         case 'M':
4885           merge_notes = TRUE;
4886           break;
4887         case OPTION_NO_MERGE_NOTES:
4888           merge_notes = FALSE;
4889           break;
4890
4891         case 'N':
4892           add_specific_symbol (optarg, strip_specific_htab);
4893           break;
4894
4895         case OPTION_STRIP_UNNEEDED_SYMBOL:
4896           add_specific_symbol (optarg, strip_unneeded_htab);
4897           break;
4898
4899         case 'L':
4900           add_specific_symbol (optarg, localize_specific_htab);
4901           break;
4902
4903         case OPTION_GLOBALIZE_SYMBOL:
4904           use_globalize = TRUE;
4905           add_specific_symbol (optarg, globalize_specific_htab);
4906           break;
4907
4908         case 'G':
4909           use_keep_global = TRUE;
4910           add_specific_symbol (optarg, keepglobal_specific_htab);
4911           break;
4912
4913         case 'W':
4914           add_specific_symbol (optarg, weaken_specific_htab);
4915           break;
4916
4917         case 'p':
4918           preserve_dates = TRUE;
4919           break;
4920
4921         case 'D':
4922           deterministic = TRUE;
4923           break;
4924
4925         case 'U':
4926           deterministic = FALSE;
4927           break;
4928
4929         case 'w':
4930           wildcard = TRUE;
4931           break;
4932
4933         case 'x':
4934           discard_locals = LOCALS_ALL;
4935           break;
4936
4937         case 'X':
4938           discard_locals = LOCALS_START_L;
4939           break;
4940
4941         case 'v':
4942           verbose = TRUE;
4943           break;
4944
4945         case 'V':
4946           show_version = TRUE;
4947           break;
4948
4949         case OPTION_FORMATS_INFO:
4950           formats_info = TRUE;
4951           break;
4952
4953         case OPTION_WEAKEN:
4954           weaken = TRUE;
4955           break;
4956
4957         case OPTION_ADD_SECTION:
4958           add_sections = init_section_add (optarg, add_sections,
4959                                            "--add-section");
4960           section_add_load_file (add_sections);
4961           break;
4962
4963         case OPTION_UPDATE_SECTION:
4964           update_sections = init_section_add (optarg, update_sections,
4965                                               "--update-section");
4966           section_add_load_file (update_sections);
4967           break;
4968
4969         case OPTION_DUMP_SECTION:
4970           dump_sections = init_section_add (optarg, dump_sections,
4971                                             "--dump-section");
4972           break;
4973
4974         case OPTION_ADD_SYMBOL:
4975           {
4976             char *s, *t;
4977             struct addsym_node *newsym = xmalloc (sizeof *newsym);
4978
4979             newsym->next = NULL;
4980             s = strchr (optarg, '=');
4981             if (s == NULL)
4982               fatal (_("bad format for %s"), "--add-symbol");
4983             t = strchr (s + 1, ':');
4984
4985             newsym->symdef = xstrndup (optarg, s - optarg);
4986             if (t)
4987               {
4988                 newsym->section = xstrndup (s + 1, t - (s + 1));
4989                 newsym->symval = strtol (t + 1, NULL, 0);
4990               }
4991             else
4992               {
4993                 newsym->section = NULL;
4994                 newsym->symval = strtol (s + 1, NULL, 0);
4995                 t = s;
4996               }
4997
4998             t = strchr (t + 1, ',');
4999             newsym->othersym = NULL;
5000             if (t)
5001               newsym->flags = parse_symflags (t+1, &newsym->othersym);
5002             else
5003               newsym->flags = BSF_GLOBAL;
5004
5005             /* Keep 'othersym' symbols at the front of the list.  */
5006             if (newsym->othersym)
5007               {
5008                 newsym->next = add_sym_list;
5009                 if (!add_sym_list)
5010                   add_sym_tail = &newsym->next;
5011                 add_sym_list = newsym;
5012               }
5013             else
5014               {
5015                 *add_sym_tail = newsym;
5016                 add_sym_tail = &newsym->next;
5017               }
5018             add_symbols++;
5019           }
5020           break;
5021
5022         case OPTION_CHANGE_START:
5023           change_start = parse_vma (optarg, "--change-start");
5024           break;
5025
5026         case OPTION_CHANGE_SECTION_ADDRESS:
5027         case OPTION_CHANGE_SECTION_LMA:
5028         case OPTION_CHANGE_SECTION_VMA:
5029           {
5030             struct section_list * p;
5031             unsigned int context = 0;
5032             const char *s;
5033             int len;
5034             char *name;
5035             char *option = NULL;
5036             bfd_vma val;
5037
5038             switch (c)
5039               {
5040               case OPTION_CHANGE_SECTION_ADDRESS:
5041                 option = "--change-section-address";
5042                 context = SECTION_CONTEXT_ALTER_LMA | SECTION_CONTEXT_ALTER_VMA;
5043                 break;
5044               case OPTION_CHANGE_SECTION_LMA:
5045                 option = "--change-section-lma";
5046                 context = SECTION_CONTEXT_ALTER_LMA;
5047                 break;
5048               case OPTION_CHANGE_SECTION_VMA:
5049                 option = "--change-section-vma";
5050                 context = SECTION_CONTEXT_ALTER_VMA;
5051                 break;
5052               }
5053
5054             s = strchr (optarg, '=');
5055             if (s == NULL)
5056               {
5057                 s = strchr (optarg, '+');
5058                 if (s == NULL)
5059                   {
5060                     s = strchr (optarg, '-');
5061                     if (s == NULL)
5062                       fatal (_("bad format for %s"), option);
5063                   }
5064               }
5065             else
5066               {
5067                 /* Correct the context.  */
5068                 switch (c)
5069                   {
5070                   case OPTION_CHANGE_SECTION_ADDRESS:
5071                     context = SECTION_CONTEXT_SET_LMA | SECTION_CONTEXT_SET_VMA;
5072                     break;
5073                   case OPTION_CHANGE_SECTION_LMA:
5074                     context = SECTION_CONTEXT_SET_LMA;
5075                     break;
5076                   case OPTION_CHANGE_SECTION_VMA:
5077                     context = SECTION_CONTEXT_SET_VMA;
5078                     break;
5079                   }
5080               }
5081
5082             len = s - optarg;
5083             name = (char *) xmalloc (len + 1);
5084             strncpy (name, optarg, len);
5085             name[len] = '\0';
5086
5087             p = find_section_list (name, TRUE, context);
5088
5089             val = parse_vma (s + 1, option);
5090             if (*s == '-')
5091               val = - val;
5092
5093             switch (c)
5094               {
5095               case OPTION_CHANGE_SECTION_ADDRESS:
5096                 p->vma_val = val;
5097                 /* Fall through.  */
5098
5099               case OPTION_CHANGE_SECTION_LMA:
5100                 p->lma_val = val;
5101                 break;
5102
5103               case OPTION_CHANGE_SECTION_VMA:
5104                 p->vma_val = val;
5105                 break;
5106               }
5107           }
5108           break;
5109
5110         case OPTION_CHANGE_ADDRESSES:
5111           change_section_address = parse_vma (optarg, "--change-addresses");
5112           change_start = change_section_address;
5113           break;
5114
5115         case OPTION_CHANGE_WARNINGS:
5116           change_warn = TRUE;
5117           break;
5118
5119         case OPTION_CHANGE_LEADING_CHAR:
5120           change_leading_char = TRUE;
5121           break;
5122
5123         case OPTION_COMPRESS_DEBUG_SECTIONS:
5124           if (optarg)
5125             {
5126               if (strcasecmp (optarg, "none") == 0)
5127                 do_debug_sections = decompress;
5128               else if (strcasecmp (optarg, "zlib") == 0)
5129                 do_debug_sections = compress_zlib;
5130               else if (strcasecmp (optarg, "zlib-gnu") == 0)
5131                 do_debug_sections = compress_gnu_zlib;
5132               else if (strcasecmp (optarg, "zlib-gabi") == 0)
5133                 do_debug_sections = compress_gabi_zlib;
5134               else
5135                 fatal (_("unrecognized --compress-debug-sections type `%s'"),
5136                        optarg);
5137             }
5138           else
5139             do_debug_sections = compress;
5140           break;
5141
5142         case OPTION_DEBUGGING:
5143           convert_debugging = TRUE;
5144           break;
5145
5146         case OPTION_DECOMPRESS_DEBUG_SECTIONS:
5147           do_debug_sections = decompress;
5148           break;
5149
5150         case OPTION_ELF_STT_COMMON:
5151           if (strcasecmp (optarg, "yes") == 0)
5152             do_elf_stt_common = elf_stt_common;
5153           else if (strcasecmp (optarg, "no") == 0)
5154             do_elf_stt_common = no_elf_stt_common;
5155           else
5156             fatal (_("unrecognized --elf-stt-common= option `%s'"),
5157                    optarg);
5158           break;
5159
5160         case OPTION_GAP_FILL:
5161           {
5162             bfd_vma gap_fill_vma;
5163
5164             gap_fill_vma = parse_vma (optarg, "--gap-fill");
5165             gap_fill = (bfd_byte) gap_fill_vma;
5166             if ((bfd_vma) gap_fill != gap_fill_vma)
5167               {
5168                 char buff[20];
5169
5170                 sprintf_vma (buff, gap_fill_vma);
5171
5172                 non_fatal (_("Warning: truncating gap-fill from 0x%s to 0x%x"),
5173                            buff, gap_fill);
5174               }
5175             gap_fill_set = TRUE;
5176           }
5177           break;
5178
5179         case OPTION_NO_CHANGE_WARNINGS:
5180           change_warn = FALSE;
5181           break;
5182
5183         case OPTION_PAD_TO:
5184           pad_to = parse_vma (optarg, "--pad-to");
5185           pad_to_set = TRUE;
5186           break;
5187
5188         case OPTION_REMOVE_LEADING_CHAR:
5189           remove_leading_char = TRUE;
5190           break;
5191
5192         case OPTION_REDEFINE_SYM:
5193           {
5194             /* Insert this redefinition onto redefine_specific_htab.  */
5195
5196             int len;
5197             const char *s;
5198             const char *nextarg;
5199             char *source, *target;
5200
5201             s = strchr (optarg, '=');
5202             if (s == NULL)
5203               fatal (_("bad format for %s"), "--redefine-sym");
5204
5205             len = s - optarg;
5206             source = (char *) xmalloc (len + 1);
5207             strncpy (source, optarg, len);
5208             source[len] = '\0';
5209
5210             nextarg = s + 1;
5211             len = strlen (nextarg);
5212             target = (char *) xmalloc (len + 1);
5213             strcpy (target, nextarg);
5214
5215             add_redefine_and_check ("--redefine-sym", source, target);
5216
5217             free (source);
5218             free (target);
5219           }
5220           break;
5221
5222         case OPTION_REDEFINE_SYMS:
5223           add_redefine_syms_file (optarg);
5224           break;
5225
5226         case OPTION_SET_SECTION_FLAGS:
5227           {
5228             struct section_list *p;
5229             const char *s;
5230             int len;
5231             char *name;
5232
5233             s = strchr (optarg, '=');
5234             if (s == NULL)
5235               fatal (_("bad format for %s"), "--set-section-flags");
5236
5237             len = s - optarg;
5238             name = (char *) xmalloc (len + 1);
5239             strncpy (name, optarg, len);
5240             name[len] = '\0';
5241
5242             p = find_section_list (name, TRUE, SECTION_CONTEXT_SET_FLAGS);
5243
5244             p->flags = parse_flags (s + 1);
5245           }
5246           break;
5247
5248         case OPTION_RENAME_SECTION:
5249           {
5250             flagword flags;
5251             const char *eq, *fl;
5252             char *old_name;
5253             char *new_name;
5254             unsigned int len;
5255
5256             eq = strchr (optarg, '=');
5257             if (eq == NULL)
5258               fatal (_("bad format for %s"), "--rename-section");
5259
5260             len = eq - optarg;
5261             if (len == 0)
5262               fatal (_("bad format for %s"), "--rename-section");
5263
5264             old_name = (char *) xmalloc (len + 1);
5265             strncpy (old_name, optarg, len);
5266             old_name[len] = 0;
5267
5268             eq++;
5269             fl = strchr (eq, ',');
5270             if (fl)
5271               {
5272                 flags = parse_flags (fl + 1);
5273                 len = fl - eq;
5274               }
5275             else
5276               {
5277                 flags = -1;
5278                 len = strlen (eq);
5279               }
5280
5281             if (len == 0)
5282               fatal (_("bad format for %s"), "--rename-section");
5283
5284             new_name = (char *) xmalloc (len + 1);
5285             strncpy (new_name, eq, len);
5286             new_name[len] = 0;
5287
5288             add_section_rename (old_name, new_name, flags);
5289           }
5290           break;
5291
5292         case OPTION_SET_START:
5293           set_start = parse_vma (optarg, "--set-start");
5294           set_start_set = TRUE;
5295           break;
5296
5297         case OPTION_SREC_LEN:
5298           _bfd_srec_len = parse_vma (optarg, "--srec-len");
5299           break;
5300
5301         case OPTION_SREC_FORCES3:
5302           _bfd_srec_forceS3 = TRUE;
5303           break;
5304
5305         case OPTION_STRIP_SYMBOLS:
5306           add_specific_symbols (optarg, strip_specific_htab,
5307                                 &strip_specific_buffer);
5308           break;
5309
5310         case OPTION_STRIP_UNNEEDED_SYMBOLS:
5311           add_specific_symbols (optarg, strip_unneeded_htab,
5312                                 &strip_unneeded_buffer);
5313           break;
5314
5315         case OPTION_KEEP_SYMBOLS:
5316           add_specific_symbols (optarg, keep_specific_htab,
5317                                 &keep_specific_buffer);
5318           break;
5319
5320         case OPTION_LOCALIZE_HIDDEN:
5321           localize_hidden = TRUE;
5322           break;
5323
5324         case OPTION_LOCALIZE_SYMBOLS:
5325           add_specific_symbols (optarg, localize_specific_htab,
5326                                 &localize_specific_buffer);
5327           break;
5328
5329         case OPTION_LONG_SECTION_NAMES:
5330           if (!strcmp ("enable", optarg))
5331             long_section_names = ENABLE;
5332           else if (!strcmp ("disable", optarg))
5333             long_section_names = DISABLE;
5334           else if (!strcmp ("keep", optarg))
5335             long_section_names = KEEP;
5336           else
5337             fatal (_("unknown long section names option '%s'"), optarg);
5338           break;
5339
5340         case OPTION_GLOBALIZE_SYMBOLS:
5341           use_globalize = TRUE;
5342           add_specific_symbols (optarg, globalize_specific_htab,
5343                                 &globalize_specific_buffer);
5344           break;
5345
5346         case OPTION_KEEPGLOBAL_SYMBOLS:
5347           use_keep_global = TRUE;
5348           add_specific_symbols (optarg, keepglobal_specific_htab,
5349                                 &keepglobal_specific_buffer);
5350           break;
5351
5352         case OPTION_WEAKEN_SYMBOLS:
5353           add_specific_symbols (optarg, weaken_specific_htab,
5354                                 &weaken_specific_buffer);
5355           break;
5356
5357         case OPTION_ALT_MACH_CODE:
5358           use_alt_mach_code = strtoul (optarg, NULL, 0);
5359           if (use_alt_mach_code == 0)
5360             fatal (_("unable to parse alternative machine code"));
5361           break;
5362
5363         case OPTION_PREFIX_SYMBOLS:
5364           prefix_symbols_string = optarg;
5365           break;
5366
5367         case OPTION_PREFIX_SECTIONS:
5368           prefix_sections_string = optarg;
5369           break;
5370
5371         case OPTION_PREFIX_ALLOC_SECTIONS:
5372           prefix_alloc_sections_string = optarg;
5373           break;
5374
5375         case OPTION_READONLY_TEXT:
5376           bfd_flags_to_set |= WP_TEXT;
5377           bfd_flags_to_clear &= ~WP_TEXT;
5378           break;
5379
5380         case OPTION_WRITABLE_TEXT:
5381           bfd_flags_to_clear |= WP_TEXT;
5382           bfd_flags_to_set &= ~WP_TEXT;
5383           break;
5384
5385         case OPTION_PURE:
5386           bfd_flags_to_set |= D_PAGED;
5387           bfd_flags_to_clear &= ~D_PAGED;
5388           break;
5389
5390         case OPTION_IMPURE:
5391           bfd_flags_to_clear |= D_PAGED;
5392           bfd_flags_to_set &= ~D_PAGED;
5393           break;
5394
5395         case OPTION_EXTRACT_DWO:
5396           strip_symbols = STRIP_NONDWO;
5397           break;
5398
5399         case OPTION_EXTRACT_SYMBOL:
5400           extract_symbol = TRUE;
5401           break;
5402
5403         case OPTION_REVERSE_BYTES:
5404           {
5405             int prev = reverse_bytes;
5406
5407             reverse_bytes = atoi (optarg);
5408             if ((reverse_bytes <= 0) || ((reverse_bytes % 2) != 0))
5409               fatal (_("number of bytes to reverse must be positive and even"));
5410
5411             if (prev && prev != reverse_bytes)
5412               non_fatal (_("Warning: ignoring previous --reverse-bytes value of %d"),
5413                          prev);
5414             break;
5415           }
5416
5417         case OPTION_FILE_ALIGNMENT:
5418           pe_file_alignment = parse_vma (optarg, "--file-alignment");
5419           break;
5420
5421         case OPTION_HEAP:
5422           {
5423             char *end;
5424             pe_heap_reserve = strtoul (optarg, &end, 0);
5425             if (end == optarg
5426                 || (*end != '.' && *end != '\0'))
5427               non_fatal (_("%s: invalid reserve value for --heap"),
5428                          optarg);
5429             else if (*end != '\0')
5430               {
5431                 pe_heap_commit = strtoul (end + 1, &end, 0);
5432                 if (*end != '\0')
5433                   non_fatal (_("%s: invalid commit value for --heap"),
5434                              optarg);
5435               }
5436           }
5437           break;
5438
5439         case OPTION_IMAGE_BASE:
5440           pe_image_base = parse_vma (optarg, "--image-base");
5441           break;
5442
5443         case OPTION_SECTION_ALIGNMENT:
5444           pe_section_alignment = parse_vma (optarg,
5445                                             "--section-alignment");
5446           break;
5447
5448         case OPTION_SUBSYSTEM:
5449           set_pe_subsystem (optarg);
5450           break;
5451
5452         case OPTION_STACK:
5453           {
5454             char *end;
5455             pe_stack_reserve = strtoul (optarg, &end, 0);
5456             if (end == optarg
5457                 || (*end != '.' && *end != '\0'))
5458               non_fatal (_("%s: invalid reserve value for --stack"),
5459                          optarg);
5460             else if (*end != '\0')
5461               {
5462                 pe_stack_commit = strtoul (end + 1, &end, 0);
5463                 if (*end != '\0')
5464                   non_fatal (_("%s: invalid commit value for --stack"),
5465                              optarg);
5466               }
5467           }
5468           break;
5469
5470         case 0:
5471           /* We've been given a long option.  */
5472           break;
5473
5474         case 'H':
5475         case 'h':
5476           copy_usage (stdout, 0);
5477
5478         default:
5479           copy_usage (stderr, 1);
5480         }
5481     }
5482
5483   if (use_globalize && use_keep_global)
5484     fatal(_("--globalize-symbol(s) is incompatible with -G/--keep-global-symbol(s)"));
5485
5486   if (formats_info)
5487     {
5488       display_info ();
5489       return 0;
5490     }
5491
5492   if (show_version)
5493     print_version ("objcopy");
5494
5495   if (interleave && copy_byte == -1)
5496     fatal (_("interleave start byte must be set with --byte"));
5497
5498   if (copy_byte >= interleave)
5499     fatal (_("byte number must be less than interleave"));
5500
5501   if (copy_width > interleave - copy_byte)
5502     fatal (_("interleave width must be less than or equal to interleave - byte`"));
5503
5504   if (optind == argc || optind + 2 < argc)
5505     copy_usage (stderr, 1);
5506
5507   input_filename = argv[optind];
5508   if (optind + 1 < argc)
5509     output_filename = argv[optind + 1];
5510
5511   default_deterministic ();
5512
5513   /* Default is to strip no symbols.  */
5514   if (strip_symbols == STRIP_UNDEF && discard_locals == LOCALS_UNDEF)
5515     strip_symbols = STRIP_NONE;
5516
5517   if (output_target == NULL)
5518     output_target = input_target;
5519
5520   /* Convert input EFI target to PEI target.  */
5521   if (input_target != NULL
5522       && strncmp (input_target, "efi-", 4) == 0)
5523     {
5524       char *efi;
5525
5526       efi = xstrdup (output_target + 4);
5527       if (strncmp (efi, "bsdrv-", 6) == 0
5528           || strncmp (efi, "rtdrv-", 6) == 0)
5529         efi += 2;
5530       else if (strncmp (efi, "app-", 4) != 0)
5531         fatal (_("unknown input EFI target: %s"), input_target);
5532
5533       input_target = efi;
5534       convert_efi_target (efi);
5535     }
5536
5537   /* Convert output EFI target to PEI target.  */
5538   if (output_target != NULL
5539       && strncmp (output_target, "efi-", 4) == 0)
5540     {
5541       char *efi;
5542
5543       efi = xstrdup (output_target + 4);
5544       if (strncmp (efi, "app-", 4) == 0)
5545         {
5546           if (pe_subsystem == -1)
5547             pe_subsystem = IMAGE_SUBSYSTEM_EFI_APPLICATION;
5548         }
5549       else if (strncmp (efi, "bsdrv-", 6) == 0)
5550         {
5551           if (pe_subsystem == -1)
5552             pe_subsystem = IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER;
5553           efi += 2;
5554         }
5555       else if (strncmp (efi, "rtdrv-", 6) == 0)
5556         {
5557           if (pe_subsystem == -1)
5558             pe_subsystem = IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER;
5559           efi += 2;
5560         }
5561       else
5562         fatal (_("unknown output EFI target: %s"), output_target);
5563
5564       if (pe_file_alignment == (bfd_vma) -1)
5565         pe_file_alignment = PE_DEF_FILE_ALIGNMENT;
5566       if (pe_section_alignment == (bfd_vma) -1)
5567         pe_section_alignment = PE_DEF_SECTION_ALIGNMENT;
5568
5569       output_target = efi;
5570       convert_efi_target (efi);
5571     }
5572
5573   if (preserve_dates)
5574     if (stat (input_filename, & statbuf) < 0)
5575       fatal (_("warning: could not locate '%s'.  System error message: %s"),
5576              input_filename, strerror (errno));
5577
5578   /* If there is no destination file, or the source and destination files
5579      are the same, then create a temp and rename the result into the input.  */
5580   if (output_filename == NULL
5581       || filename_cmp (input_filename, output_filename) == 0)
5582     tmpname = make_tempname (input_filename);
5583   else
5584     tmpname = output_filename;
5585
5586   if (tmpname == NULL)
5587     fatal (_("warning: could not create temporary file whilst copying '%s', (error: %s)"),
5588            input_filename, strerror (errno));
5589
5590   copy_file (input_filename, tmpname, input_target, output_target, input_arch);
5591   if (status == 0)
5592     {
5593       if (preserve_dates)
5594         set_times (tmpname, &statbuf);
5595       if (tmpname != output_filename)
5596         status = (smart_rename (tmpname, input_filename,
5597                                 preserve_dates) != 0);
5598     }
5599   else
5600     unlink_if_ordinary (tmpname);
5601
5602   if (tmpname != output_filename)
5603     free (tmpname);
5604
5605   if (change_warn)
5606     {
5607       struct section_list *p;
5608
5609       for (p = change_sections; p != NULL; p = p->next)
5610         {
5611           if (! p->used)
5612             {
5613               if (p->context & (SECTION_CONTEXT_SET_VMA | SECTION_CONTEXT_ALTER_VMA))
5614                 {
5615                   char buff [20];
5616
5617                   sprintf_vma (buff, p->vma_val);
5618
5619                   /* xgettext:c-format */
5620                   non_fatal (_("%s %s%c0x%s never used"),
5621                              "--change-section-vma",
5622                              p->pattern,
5623                              p->context & SECTION_CONTEXT_SET_VMA ? '=' : '+',
5624                              buff);
5625                 }
5626
5627               if (p->context & (SECTION_CONTEXT_SET_LMA | SECTION_CONTEXT_ALTER_LMA))
5628                 {
5629                   char buff [20];
5630
5631                   sprintf_vma (buff, p->lma_val);
5632
5633                   /* xgettext:c-format */
5634                   non_fatal (_("%s %s%c0x%s never used"),
5635                              "--change-section-lma",
5636                              p->pattern,
5637                              p->context & SECTION_CONTEXT_SET_LMA ? '=' : '+',
5638                              buff);
5639                 }
5640             }
5641         }
5642     }
5643
5644   if (strip_specific_buffer)
5645     free (strip_specific_buffer);
5646
5647   if (strip_unneeded_buffer)
5648     free (strip_unneeded_buffer);
5649
5650   if (keep_specific_buffer)
5651     free (keep_specific_buffer);
5652
5653   if (localize_specific_buffer)
5654     free (globalize_specific_buffer);
5655
5656   if (globalize_specific_buffer)
5657     free (globalize_specific_buffer);
5658
5659   if (keepglobal_specific_buffer)
5660     free (keepglobal_specific_buffer);
5661
5662   if (weaken_specific_buffer)
5663     free (weaken_specific_buffer);
5664
5665   return 0;
5666 }
5667
5668 int
5669 main (int argc, char *argv[])
5670 {
5671 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
5672   setlocale (LC_MESSAGES, "");
5673 #endif
5674 #if defined (HAVE_SETLOCALE)
5675   setlocale (LC_CTYPE, "");
5676 #endif
5677   bindtextdomain (PACKAGE, LOCALEDIR);
5678   textdomain (PACKAGE);
5679
5680   program_name = argv[0];
5681   xmalloc_set_program_name (program_name);
5682
5683   START_PROGRESS (program_name, 0);
5684
5685   expandargv (&argc, &argv);
5686
5687   strip_symbols = STRIP_UNDEF;
5688   discard_locals = LOCALS_UNDEF;
5689
5690   if (bfd_init () != BFD_INIT_MAGIC)
5691     fatal (_("fatal error: libbfd ABI mismatch"));
5692   set_default_bfd_target ();
5693
5694   if (is_strip < 0)
5695     {
5696       int i = strlen (program_name);
5697 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
5698       /* Drop the .exe suffix, if any.  */
5699       if (i > 4 && FILENAME_CMP (program_name + i - 4, ".exe") == 0)
5700         {
5701           i -= 4;
5702           program_name[i] = '\0';
5703         }
5704 #endif
5705       is_strip = (i >= 5 && FILENAME_CMP (program_name + i - 5, "strip") == 0);
5706     }
5707
5708   create_symbol_htabs ();
5709
5710   if (argv != NULL)
5711     bfd_set_error_program_name (argv[0]);
5712
5713   if (is_strip)
5714     strip_main (argc, argv);
5715   else
5716     copy_main (argc, argv);
5717
5718   END_PROGRESS (program_name);
5719
5720   return status;
5721 }