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