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