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