projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* config/tc-xtensa.c (xg_assembly_relax): Increment steps_taken for
[deliverable/binutils-gdb.git] / binutils / objcopy.c
CommitLineData
252b5132 1/* objcopy.c -- copy object file from input to output, optionally massaging it.
8c2bc687 2 Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
6e2c86ac 3 2001, 2002, 2003, 2004, 2005, 2006
252b5132
RH		 4 Free Software Foundation, Inc.
5
6 This file is part of GNU Binutils.
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
b43b5d5f
NC		 20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
21 02110-1301, USA. */
252b5132
RH		 22\f
23#include "bfd.h"
24#include "progress.h"
25#include "bucomm.h"
26#include "getopt.h"
27#include "libiberty.h"
28#include "budbg.h"
5af11cab 29#include "filenames.h"
5fe11841 30#include "fnmatch.h"
f0312d39 31#include "elf-bfd.h"
252b5132 32#include <sys/stat.h>
6e2c86ac 33#include "libbfd.h"
252b5132
RH		 34
35/* A list of symbols to explicitly strip out, or to keep. A linked
36 list is good enough for a small number from the command line, but
37 this will slow things down a lot if many symbols are being
0af11b59 38 deleted. */
252b5132
RH		 39
40struct symlist
41{
42 const char *name;
43 struct symlist *next;
44};
45
57938635
AM		 46/* A list to support redefine_sym. */
47struct redefine_node
48{
49 char *source;
50 char *target;
51 struct redefine_node *next;
52};
53
594ef5db
NC		 54typedef struct section_rename
55{
56 const char * old_name;
57 const char * new_name;
58 flagword flags;
59 struct section_rename * next;
60}
61section_rename;
62
63/* List of sections to be renamed. */
84e2f313 64static section_rename *section_rename_list;
594ef5db 65
252b5132
RH		 66#define RETURN_NONFATAL(s) {bfd_nonfatal (s); status = 1; return;}
67
84e2f313
NC		 68static asymbol **isympp = NULL; /* Input symbols. */
69static asymbol **osympp = NULL; /* Output symbols that survive stripping. */
252b5132
RH		 70
71/* If `copy_byte' >= 0, copy only that byte of every `interleave' bytes. */
72static int copy_byte = -1;
73static int interleave = 4;
74
b34976b6
AM		 75static bfd_boolean verbose; /* Print file and target names. */
76static bfd_boolean preserve_dates; /* Preserve input file timestamp. */
252b5132
RH		 77static int status = 0; /* Exit status. */
78
79enum strip_action
80 {
81 STRIP_UNDEF,
84e2f313
NC		 82 STRIP_NONE, /* Don't strip. */
83 STRIP_DEBUG, /* Strip all debugger symbols. */
84 STRIP_UNNEEDED, /* Strip unnecessary symbols. */
ed1653a7 85 STRIP_NONDEBUG, /* Strip everything but debug info. */
84e2f313 86 STRIP_ALL /* Strip all symbols. */
252b5132
RH		 87 };
88
0af11b59 89/* Which symbols to remove. */
252b5132
RH		 90static enum strip_action strip_symbols;
91
92enum locals_action
93 {
94 LOCALS_UNDEF,
84e2f313
NC		 95 LOCALS_START_L, /* Discard locals starting with L. */
96 LOCALS_ALL /* Discard all locals. */
252b5132
RH		 97 };
98
99/* Which local symbols to remove. Overrides STRIP_ALL. */
100static enum locals_action discard_locals;
101
102/* What kind of change to perform. */
103enum change_action
104{
105 CHANGE_IGNORE,
106 CHANGE_MODIFY,
107 CHANGE_SET
108};
109
110/* Structure used to hold lists of sections and actions to take. */
111struct section_list
112{
b34976b6
AM		 113 struct section_list * next; /* Next section to change. */
114 const char * name; /* Section name. */
115 bfd_boolean used; /* Whether this entry was used. */
116 bfd_boolean remove; /* Whether to remove this section. */
117 bfd_boolean copy; /* Whether to copy this section. */
118 enum change_action change_vma;/* Whether to change or set VMA. */
119 bfd_vma vma_val; /* Amount to change by or set to. */
120 enum change_action change_lma;/* Whether to change or set LMA. */
121 bfd_vma lma_val; /* Amount to change by or set to. */
122 bfd_boolean set_flags; /* Whether to set the section flags. */
123 flagword flags; /* What to set the section flags to. */
252b5132
RH		 124};
125
126static struct section_list *change_sections;
594ef5db 127
b34976b6
AM		 128/* TRUE if some sections are to be removed. */
129static bfd_boolean sections_removed;
594ef5db 130
b34976b6
AM		 131/* TRUE if only some sections are to be copied. */
132static bfd_boolean sections_copied;
252b5132
RH		 133
134/* Changes to the start address. */
135static bfd_vma change_start = 0;
b34976b6 136static bfd_boolean set_start_set = FALSE;
252b5132
RH		 137static bfd_vma set_start;
138
139/* Changes to section addresses. */
140static bfd_vma change_section_address = 0;
141
142/* Filling gaps between sections. */
b34976b6 143static bfd_boolean gap_fill_set = FALSE;
252b5132
RH		 144static bfd_byte gap_fill = 0;
145
146/* Pad to a given address. */
b34976b6 147static bfd_boolean pad_to_set = FALSE;
252b5132
RH		 148static bfd_vma pad_to;
149
1ae8b3d2
AO		 150/* Use alternate machine code? */
151static int use_alt_mach_code = 0;
152
4087920c
MR		 153/* Output BFD flags user wants to set or clear */
154static flagword bfd_flags_to_set;
155static flagword bfd_flags_to_clear;
156
252b5132 157/* List of sections to add. */
252b5132
RH		 158struct section_add
159{
160 /* Next section to add. */
161 struct section_add *next;
162 /* Name of section to add. */
163 const char *name;
164 /* Name of file holding section contents. */
165 const char *filename;
166 /* Size of file. */
167 size_t size;
168 /* Contents of file. */
169 bfd_byte *contents;
170 /* BFD section, after it has been added. */
171 asection *section;
172};
173
594ef5db 174/* List of sections to add to the output BFD. */
252b5132
RH		 175static struct section_add *add_sections;
176
2593f09a
NC		 177/* If non-NULL the argument to --add-gnu-debuglink.
178 This should be the filename to store in the .gnu_debuglink section. */
179static const char * gnu_debuglink_filename = NULL;
180
252b5132 181/* Whether to convert debugging information. */
b34976b6 182static bfd_boolean convert_debugging = FALSE;
252b5132
RH		 183
184/* Whether to change the leading character in symbol names. */
b34976b6 185static bfd_boolean change_leading_char = FALSE;
252b5132
RH		 186
187/* Whether to remove the leading character from global symbol names. */
b34976b6 188static bfd_boolean remove_leading_char = FALSE;
252b5132 189
aaad4cf3 190/* Whether to permit wildcard in symbol comparison. */
5fe11841
NC		 191static bfd_boolean wildcard = FALSE;
192
16b2b71c
NC		 193/* List of symbols to strip, keep, localize, keep-global, weaken,
194 or redefine. */
252b5132 195static struct symlist *strip_specific_list = NULL;
bcf32829 196static struct symlist *strip_unneeded_list = NULL;
252b5132
RH		 197static struct symlist *keep_specific_list = NULL;
198static struct symlist *localize_specific_list = NULL;
7b4a0685 199static struct symlist *globalize_specific_list = NULL;
16b2b71c 200static struct symlist *keepglobal_specific_list = NULL;
252b5132 201static struct symlist *weaken_specific_list = NULL;
57938635 202static struct redefine_node *redefine_sym_list = NULL;
252b5132 203
b34976b6
AM		 204/* If this is TRUE, we weaken global symbols (set BSF_WEAK). */
205static bfd_boolean weaken = FALSE;
252b5132 206
1637cd90
JB		 207/* If this is TRUE, we retain BSF_FILE symbols. */
208static bfd_boolean keep_file_symbols = FALSE;
209
d7fb0dd2
NC		 210/* Prefix symbols/sections. */
211static char *prefix_symbols_string = 0;
212static char *prefix_sections_string = 0;
213static char *prefix_alloc_sections_string = 0;
214
252b5132 215/* 150 isn't special; it's just an arbitrary non-ASCII char value. */
84e2f313
NC		 216enum command_line_switch
217 {
218 OPTION_ADD_SECTION=150,
219 OPTION_CHANGE_ADDRESSES,
220 OPTION_CHANGE_LEADING_CHAR,
221 OPTION_CHANGE_START,
222 OPTION_CHANGE_SECTION_ADDRESS,
223 OPTION_CHANGE_SECTION_LMA,
224 OPTION_CHANGE_SECTION_VMA,
225 OPTION_CHANGE_WARNINGS,
226 OPTION_DEBUGGING,
227 OPTION_GAP_FILL,
228 OPTION_NO_CHANGE_WARNINGS,
229 OPTION_PAD_TO,
230 OPTION_REMOVE_LEADING_CHAR,
231 OPTION_SET_SECTION_FLAGS,
232 OPTION_SET_START,
233 OPTION_STRIP_UNNEEDED,
234 OPTION_WEAKEN,
235 OPTION_REDEFINE_SYM,
236 OPTION_REDEFINE_SYMS,
237 OPTION_SREC_LEN,
238 OPTION_SREC_FORCES3,
239 OPTION_STRIP_SYMBOLS,
bcf32829
JB		 240 OPTION_STRIP_UNNEEDED_SYMBOL,
241 OPTION_STRIP_UNNEEDED_SYMBOLS,
84e2f313
NC		 242 OPTION_KEEP_SYMBOLS,
243 OPTION_LOCALIZE_SYMBOLS,
7b4a0685
NC		 244 OPTION_GLOBALIZE_SYMBOL,
245 OPTION_GLOBALIZE_SYMBOLS,
84e2f313
NC		 246 OPTION_KEEPGLOBAL_SYMBOLS,
247 OPTION_WEAKEN_SYMBOLS,
248 OPTION_RENAME_SECTION,
249 OPTION_ALT_MACH_CODE,
250 OPTION_PREFIX_SYMBOLS,
251 OPTION_PREFIX_SECTIONS,
252 OPTION_PREFIX_ALLOC_SECTIONS,
253 OPTION_FORMATS_INFO,
254 OPTION_ADD_GNU_DEBUGLINK,
4087920c 255 OPTION_ONLY_KEEP_DEBUG,
1637cd90 256 OPTION_KEEP_FILE_SYMBOLS,
4087920c
MR		 257 OPTION_READONLY_TEXT,
258 OPTION_WRITABLE_TEXT,
259 OPTION_PURE,
260 OPTION_IMPURE
84e2f313 261 };
252b5132
RH		 262
263/* Options to handle if running as "strip". */
264
265static struct option strip_options[] =
266{
267 {"discard-all", no_argument, 0, 'x'},
268 {"discard-locals", no_argument, 0, 'X'},
269 {"format", required_argument, 0, 'F'}, /* Obsolete */
270 {"help", no_argument, 0, 'h'},
7c29036b 271 {"info", no_argument, 0, OPTION_FORMATS_INFO},
252b5132
RH		 272 {"input-format", required_argument, 0, 'I'}, /* Obsolete */
273 {"input-target", required_argument, 0, 'I'},
1637cd90 274 {"keep-file-symbols", no_argument, 0, OPTION_KEEP_FILE_SYMBOLS},
252b5132 275 {"keep-symbol", required_argument, 0, 'K'},
ed1653a7 276 {"only-keep-debug", no_argument, 0, OPTION_ONLY_KEEP_DEBUG},
252b5132
RH		 277 {"output-format", required_argument, 0, 'O'}, /* Obsolete */
278 {"output-target", required_argument, 0, 'O'},
af3bdff7 279 {"output-file", required_argument, 0, 'o'},
252b5132
RH		 280 {"preserve-dates", no_argument, 0, 'p'},
281 {"remove-section", required_argument, 0, 'R'},
282 {"strip-all", no_argument, 0, 's'},
283 {"strip-debug", no_argument, 0, 'S'},
284 {"strip-unneeded", no_argument, 0, OPTION_STRIP_UNNEEDED},
285 {"strip-symbol", required_argument, 0, 'N'},
286 {"target", required_argument, 0, 'F'},
287 {"verbose", no_argument, 0, 'v'},
288 {"version", no_argument, 0, 'V'},
5fe11841 289 {"wildcard", no_argument, 0, 'w'},
252b5132
RH		 290 {0, no_argument, 0, 0}
291};
292
293/* Options to handle if running as "objcopy". */
294
295static struct option copy_options[] =
296{
2593f09a 297 {"add-gnu-debuglink", required_argument, 0, OPTION_ADD_GNU_DEBUGLINK},
252b5132
RH		 298 {"add-section", required_argument, 0, OPTION_ADD_SECTION},
299 {"adjust-start", required_argument, 0, OPTION_CHANGE_START},
300 {"adjust-vma", required_argument, 0, OPTION_CHANGE_ADDRESSES},
301 {"adjust-section-vma", required_argument, 0, OPTION_CHANGE_SECTION_ADDRESS},
302 {"adjust-warnings", no_argument, 0, OPTION_CHANGE_WARNINGS},
d7fb0dd2 303 {"alt-machine-code", required_argument, 0, OPTION_ALT_MACH_CODE},
43a0748c 304 {"binary-architecture", required_argument, 0, 'B'},
252b5132
RH		 305 {"byte", required_argument, 0, 'b'},
306 {"change-addresses", required_argument, 0, OPTION_CHANGE_ADDRESSES},
307 {"change-leading-char", no_argument, 0, OPTION_CHANGE_LEADING_CHAR},
308 {"change-section-address", required_argument, 0, OPTION_CHANGE_SECTION_ADDRESS},
309 {"change-section-lma", required_argument, 0, OPTION_CHANGE_SECTION_LMA},
310 {"change-section-vma", required_argument, 0, OPTION_CHANGE_SECTION_VMA},
311 {"change-start", required_argument, 0, OPTION_CHANGE_START},
312 {"change-warnings", no_argument, 0, OPTION_CHANGE_WARNINGS},
313 {"debugging", no_argument, 0, OPTION_DEBUGGING},
314 {"discard-all", no_argument, 0, 'x'},
315 {"discard-locals", no_argument, 0, 'X'},
316 {"format", required_argument, 0, 'F'}, /* Obsolete */
317 {"gap-fill", required_argument, 0, OPTION_GAP_FILL},
7b4a0685
NC		 318 {"globalize-symbol", required_argument, 0, OPTION_GLOBALIZE_SYMBOL},
319 {"globalize-symbols", required_argument, 0, OPTION_GLOBALIZE_SYMBOLS},
252b5132 320 {"help", no_argument, 0, 'h'},
4087920c 321 {"impure", no_argument, 0, OPTION_IMPURE},
7c29036b 322 {"info", no_argument, 0, OPTION_FORMATS_INFO},
252b5132
RH		 323 {"input-format", required_argument, 0, 'I'}, /* Obsolete */
324 {"input-target", required_argument, 0, 'I'},
325 {"interleave", required_argument, 0, 'i'},
1637cd90 326 {"keep-file-symbols", no_argument, 0, OPTION_KEEP_FILE_SYMBOLS},
d7fb0dd2
NC		 327 {"keep-global-symbol", required_argument, 0, 'G'},
328 {"keep-global-symbols", required_argument, 0, OPTION_KEEPGLOBAL_SYMBOLS},
252b5132 329 {"keep-symbol", required_argument, 0, 'K'},
d7fb0dd2
NC		 330 {"keep-symbols", required_argument, 0, OPTION_KEEP_SYMBOLS},
331 {"localize-symbol", required_argument, 0, 'L'},
332 {"localize-symbols", required_argument, 0, OPTION_LOCALIZE_SYMBOLS},
252b5132
RH		 333 {"no-adjust-warnings", no_argument, 0, OPTION_NO_CHANGE_WARNINGS},
334 {"no-change-warnings", no_argument, 0, OPTION_NO_CHANGE_WARNINGS},
ed1653a7 335 {"only-keep-debug", no_argument, 0, OPTION_ONLY_KEEP_DEBUG},
d7fb0dd2 336 {"only-section", required_argument, 0, 'j'},
252b5132
RH		 337 {"output-format", required_argument, 0, 'O'}, /* Obsolete */
338 {"output-target", required_argument, 0, 'O'},
339 {"pad-to", required_argument, 0, OPTION_PAD_TO},
d7fb0dd2
NC		 340 {"prefix-symbols", required_argument, 0, OPTION_PREFIX_SYMBOLS},
341 {"prefix-sections", required_argument, 0, OPTION_PREFIX_SECTIONS},
342 {"prefix-alloc-sections", required_argument, 0, OPTION_PREFIX_ALLOC_SECTIONS},
252b5132 343 {"preserve-dates", no_argument, 0, 'p'},
4087920c
MR		 344 {"pure", no_argument, 0, OPTION_PURE},
345 {"readonly-text", no_argument, 0, OPTION_READONLY_TEXT},
d7fb0dd2 346 {"redefine-sym", required_argument, 0, OPTION_REDEFINE_SYM},
92991082 347 {"redefine-syms", required_argument, 0, OPTION_REDEFINE_SYMS},
252b5132
RH		 348 {"remove-leading-char", no_argument, 0, OPTION_REMOVE_LEADING_CHAR},
349 {"remove-section", required_argument, 0, 'R'},
594ef5db 350 {"rename-section", required_argument, 0, OPTION_RENAME_SECTION},
252b5132
RH		 351 {"set-section-flags", required_argument, 0, OPTION_SET_SECTION_FLAGS},
352 {"set-start", required_argument, 0, OPTION_SET_START},
d7fb0dd2
NC		 353 {"srec-len", required_argument, 0, OPTION_SREC_LEN},
354 {"srec-forceS3", no_argument, 0, OPTION_SREC_FORCES3},
252b5132
RH		 355 {"strip-all", no_argument, 0, 'S'},
356 {"strip-debug", no_argument, 0, 'g'},
357 {"strip-unneeded", no_argument, 0, OPTION_STRIP_UNNEEDED},
bcf32829
JB		 358 {"strip-unneeded-symbol", required_argument, 0, OPTION_STRIP_UNNEEDED_SYMBOL},
359 {"strip-unneeded-symbols", required_argument, 0, OPTION_STRIP_UNNEEDED_SYMBOLS},
252b5132 360 {"strip-symbol", required_argument, 0, 'N'},
d7fb0dd2 361 {"strip-symbols", required_argument, 0, OPTION_STRIP_SYMBOLS},
252b5132
RH		 362 {"target", required_argument, 0, 'F'},
363 {"verbose", no_argument, 0, 'v'},
364 {"version", no_argument, 0, 'V'},
365 {"weaken", no_argument, 0, OPTION_WEAKEN},
366 {"weaken-symbol", required_argument, 0, 'W'},
16b2b71c 367 {"weaken-symbols", required_argument, 0, OPTION_WEAKEN_SYMBOLS},
5fe11841 368 {"wildcard", no_argument, 0, 'w'},
4087920c 369 {"writable-text", no_argument, 0, OPTION_WRITABLE_TEXT},
252b5132
RH		 370 {0, no_argument, 0, 0}
371};
372
373/* IMPORTS */
374extern char *program_name;
375
376/* This flag distinguishes between strip and objcopy:
377 1 means this is 'strip'; 0 means this is 'objcopy'.
0af11b59 378 -1 means if we should use argv[0] to decide. */
252b5132
RH		 379extern int is_strip;
380
420496c1
NC		 381/* The maximum length of an S record. This variable is declared in srec.c
382 and can be modified by the --srec-len parameter. */
383extern unsigned int Chunk;
384
385/* Restrict the generation of Srecords to type S3 only.
386 This variable is declare in bfd/srec.c and can be toggled
387 on by the --srec-forceS3 command line switch. */
b34976b6 388extern bfd_boolean S3Forced;
252b5132 389
b749473b
NC		 390/* Defined in bfd/binary.c. Used to set architecture and machine of input
391 binary files. */
392extern enum bfd_architecture bfd_external_binary_architecture;
393extern unsigned long bfd_external_machine;
43a0748c 394
d3ba0551
AM		 395/* Forward declarations. */
396static void setup_section (bfd *, asection *, void *);
80fccad2 397static void setup_bfd_headers (bfd *, bfd *);
d3ba0551
AM		 398static void copy_section (bfd *, asection *, void *);
399static void get_sections (bfd *, asection *, void *);
400static int compare_section_lma (const void *, const void *);
401static void mark_symbols_used_in_relocations (bfd *, asection *, void *);
402static bfd_boolean write_debugging_info (bfd *, void *, long *, asymbol ***);
403static const char *lookup_sym_redefinition (const char *);
594ef5db 404\f
252b5132 405static void
84e2f313 406copy_usage (FILE *stream, int exit_status)
252b5132 407{
8b53311e
NC		 408 fprintf (stream, _("Usage: %s [option(s)] in-file [out-file]\n"), program_name);
409 fprintf (stream, _(" Copies a binary file, possibly transforming it in the process\n"));
6364e0b4 410 fprintf (stream, _(" The options are:\n"));
252b5132 411 fprintf (stream, _("\
d5bcb29d
NC		 412 -I --input-target <bfdname> Assume input file is in format <bfdname>\n\
413 -O --output-target <bfdname> Create an output file in format <bfdname>\n\
43a0748c 414 -B --binary-architecture <arch> Set arch of output file, when input is binary\n\
d5bcb29d
NC		 415 -F --target <bfdname> Set both input and output format to <bfdname>\n\
416 --debugging Convert debugging information, if possible\n\
417 -p --preserve-dates Copy modified/access timestamps to the output\n\
418 -j --only-section <name> Only copy section <name> into the output\n\
2593f09a 419 --add-gnu-debuglink=<file> Add section .gnu_debuglink linking to <file>\n\
d5bcb29d
NC		 420 -R --remove-section <name> Remove section <name> from the output\n\
421 -S --strip-all Remove all symbol and relocation information\n\
2593f09a 422 -g --strip-debug Remove all debugging symbols & sections\n\
d5bcb29d
NC		 423 --strip-unneeded Remove all symbols not needed by relocations\n\
424 -N --strip-symbol <name> Do not copy symbol <name>\n\
bcf32829
JB		 425 --strip-unneeded-symbol <name>\n\
426 Do not copy symbol <name> unless needed by\n\
427 relocations\n\
6ea3dd37 428 --only-keep-debug Strip everything but the debug information\n\
e7f918ad 429 -K --keep-symbol <name> Do not strip symbol <name>\n\
1637cd90 430 --keep-file-symbols Do not strip file symbol(s)\n\
d5bcb29d 431 -L --localize-symbol <name> Force symbol <name> to be marked as a local\n\
7b4a0685 432 --globalize-symbol <name> Force symbol <name> to be marked as a global\n\
16b2b71c 433 -G --keep-global-symbol <name> Localize all symbols except <name>\n\
d5bcb29d
NC		 434 -W --weaken-symbol <name> Force symbol <name> to be marked as a weak\n\
435 --weaken Force all global symbols to be marked as weak\n\
a95b5cf9 436 -w --wildcard Permit wildcard in symbol comparison\n\
d5bcb29d
NC		 437 -x --discard-all Remove all non-global symbols\n\
438 -X --discard-locals Remove any compiler-generated symbols\n\
439 -i --interleave <number> Only copy one out of every <number> bytes\n\
440 -b --byte <num> Select byte <num> in every interleaved block\n\
441 --gap-fill <val> Fill gaps between sections with <val>\n\
442 --pad-to <addr> Pad the last section up to address <addr>\n\
443 --set-start <addr> Set the start address to <addr>\n\
444 {--change-start|--adjust-start} <incr>\n\
445 Add <incr> to the start address\n\
446 {--change-addresses|--adjust-vma} <incr>\n\
447 Add <incr> to LMA, VMA and start addresses\n\
448 {--change-section-address|--adjust-section-vma} <name>{=|+|-}<val>\n\
449 Change LMA and VMA of section <name> by <val>\n\
450 --change-section-lma <name>{=|+|-}<val>\n\
451 Change the LMA of section <name> by <val>\n\
452 --change-section-vma <name>{=|+|-}<val>\n\
453 Change the VMA of section <name> by <val>\n\
454 {--[no-]change-warnings|--[no-]adjust-warnings}\n\
455 Warn if a named section does not exist\n\
456 --set-section-flags <name>=<flags>\n\
457 Set section <name>'s properties to <flags>\n\
458 --add-section <name>=<file> Add section <name> found in <file> to output\n\
594ef5db 459 --rename-section <old>=<new>[,<flags>] Rename section <old> to <new>\n\
d5bcb29d
NC		 460 --change-leading-char Force output format's leading character style\n\
461 --remove-leading-char Remove leading character from global symbols\n\
57938635 462 --redefine-sym <old>=<new> Redefine symbol name <old> to <new>\n\
92991082
JT		 463 --redefine-syms <file> --redefine-sym for all symbol pairs \n\
464 listed in <file>\n\
420496c1
NC		 465 --srec-len <number> Restrict the length of generated Srecords\n\
466 --srec-forceS3 Restrict the type of generated Srecords to S3\n\
16b2b71c 467 --strip-symbols <file> -N for all symbols listed in <file>\n\
bcf32829
JB		 468 --strip-unneeded-symbols <file>\n\
469 --strip-unneeded-symbol for all symbols listed\n\
470 in <file>\n\
16b2b71c
NC		 471 --keep-symbols <file> -K for all symbols listed in <file>\n\
472 --localize-symbols <file> -L for all symbols listed in <file>\n\
7b4a0685 473 --globalize-symbols <file> --globalize-symbol for all in <file>\n\
16b2b71c
NC		 474 --keep-global-symbols <file> -G for all symbols listed in <file>\n\
475 --weaken-symbols <file> -W for all symbols listed in <file>\n\
1ae8b3d2 476 --alt-machine-code <index> Use alternate machine code for output\n\
4087920c
MR		 477 --writable-text Mark the output text as writable\n\
478 --readonly-text Make the output text write protected\n\
479 --pure Mark the output file as demand paged\n\
480 --impure Mark the output file as impure\n\
d7fb0dd2
NC		 481 --prefix-symbols <prefix> Add <prefix> to start of every symbol name\n\
482 --prefix-sections <prefix> Add <prefix> to start of every section name\n\
483 --prefix-alloc-sections <prefix>\n\
484 Add <prefix> to start of every allocatable\n\
485 section name\n\
d5bcb29d 486 -v --verbose List all object files modified\n\
07012eee 487 @<file> Read options from <file>\n\
d5bcb29d
NC		 488 -V --version Display this program's version number\n\
489 -h --help Display this output\n\
7c29036b 490 --info List object formats & architectures supported\n\
d5bcb29d 491"));
252b5132
RH		 492 list_supported_targets (program_name, stream);
493 if (exit_status == 0)
8ad3436c 494 fprintf (stream, _("Report bugs to %s\n"), REPORT_BUGS_TO);
252b5132
RH		 495 exit (exit_status);
496}
497
498static void
84e2f313 499strip_usage (FILE *stream, int exit_status)
252b5132 500{
8b53311e
NC		 501 fprintf (stream, _("Usage: %s <option(s)> in-file(s)\n"), program_name);
502 fprintf (stream, _(" Removes symbols and sections from files\n"));
6364e0b4 503 fprintf (stream, _(" The options are:\n"));
252b5132 504 fprintf (stream, _("\
8b53311e
NC		 505 -I --input-target=<bfdname> Assume input file is in format <bfdname>\n\
506 -O --output-target=<bfdname> Create an output file in format <bfdname>\n\
507 -F --target=<bfdname> Set both input and output format to <bfdname>\n\
d5bcb29d 508 -p --preserve-dates Copy modified/access timestamps to the output\n\
8b53311e 509 -R --remove-section=<name> Remove section <name> from the output\n\
d5bcb29d 510 -s --strip-all Remove all symbol and relocation information\n\
2593f09a 511 -g -S -d --strip-debug Remove all debugging symbols & sections\n\
d5bcb29d 512 --strip-unneeded Remove all symbols not needed by relocations\n\
6ea3dd37 513 --only-keep-debug Strip everything but the debug information\n\
8b53311e 514 -N --strip-symbol=<name> Do not copy symbol <name>\n\
5219e4c0 515 -K --keep-symbol=<name> Do not strip symbol <name>\n\
1637cd90 516 --keep-file-symbols Do not strip file symbol(s)\n\
a95b5cf9 517 -w --wildcard Permit wildcard in symbol comparison\n\
d5bcb29d
NC		 518 -x --discard-all Remove all non-global symbols\n\
519 -X --discard-locals Remove any compiler-generated symbols\n\
520 -v --verbose List all object files modified\n\
521 -V --version Display this program's version number\n\
522 -h --help Display this output\n\
7c29036b 523 --info List object formats & architectures supported\n\
d5bcb29d
NC		 524 -o <file> Place stripped output into <file>\n\
525"));
526
252b5132
RH		 527 list_supported_targets (program_name, stream);
528 if (exit_status == 0)
8ad3436c 529 fprintf (stream, _("Report bugs to %s\n"), REPORT_BUGS_TO);
252b5132
RH		 530 exit (exit_status);
531}
532
533/* Parse section flags into a flagword, with a fatal error if the
534 string can't be parsed. */
535
536static flagword
84e2f313 537parse_flags (const char *s)
252b5132
RH		 538{
539 flagword ret;
540 const char *snext;
541 int len;
542
543 ret = SEC_NO_FLAGS;
544
545 do
546 {
547 snext = strchr (s, ',');
548 if (snext == NULL)
549 len = strlen (s);
550 else
551 {
552 len = snext - s;
553 ++snext;
554 }
555
556 if (0) ;
557#define PARSE_FLAG(fname,fval) \
558 else if (strncasecmp (fname, s, len) == 0) ret |= fval
559 PARSE_FLAG ("alloc", SEC_ALLOC);
560 PARSE_FLAG ("load", SEC_LOAD);
3994e2c6 561 PARSE_FLAG ("noload", SEC_NEVER_LOAD);
252b5132 562 PARSE_FLAG ("readonly", SEC_READONLY);
3994e2c6 563 PARSE_FLAG ("debug", SEC_DEBUGGING);
252b5132
RH		 564 PARSE_FLAG ("code", SEC_CODE);
565 PARSE_FLAG ("data", SEC_DATA);
566 PARSE_FLAG ("rom", SEC_ROM);
ebe372c1 567 PARSE_FLAG ("share", SEC_COFF_SHARED);
252b5132
RH		 568 PARSE_FLAG ("contents", SEC_HAS_CONTENTS);
569#undef PARSE_FLAG
570 else
571 {
572 char *copy;
573
574 copy = xmalloc (len + 1);
575 strncpy (copy, s, len);
576 copy[len] = '\0';
577 non_fatal (_("unrecognized section flag `%s'"), copy);
57938635
AM		 578 fatal (_("supported flags: %s"),
579 "alloc, load, noload, readonly, debug, code, data, rom, share, contents");
252b5132
RH		 580 }
581
582 s = snext;
583 }
584 while (s != NULL);
585
586 return ret;
587}
588
589/* Find and optionally add an entry in the change_sections list. */
590
591static struct section_list *
84e2f313 592find_section_list (const char *name, bfd_boolean add)
252b5132 593{
84e2f313 594 struct section_list *p;
252b5132
RH		 595
596 for (p = change_sections; p != NULL; p = p->next)
597 if (strcmp (p->name, name) == 0)
598 return p;
599
600 if (! add)
601 return NULL;
602
d3ba0551 603 p = xmalloc (sizeof (struct section_list));
252b5132 604 p->name = name;
b34976b6
AM		 605 p->used = FALSE;
606 p->remove = FALSE;
607 p->copy = FALSE;
252b5132
RH		 608 p->change_vma = CHANGE_IGNORE;
609 p->change_lma = CHANGE_IGNORE;
610 p->vma_val = 0;
611 p->lma_val = 0;
b34976b6 612 p->set_flags = FALSE;
252b5132
RH		 613 p->flags = 0;
614
615 p->next = change_sections;
616 change_sections = p;
617
618 return p;
619}
620
621/* Add a symbol to strip_specific_list. */
622
57938635 623static void
84e2f313 624add_specific_symbol (const char *name, struct symlist **list)
252b5132
RH		 625{
626 struct symlist *tmp_list;
627
d3ba0551 628 tmp_list = xmalloc (sizeof (struct symlist));
252b5132
RH		 629 tmp_list->name = name;
630 tmp_list->next = *list;
631 *list = tmp_list;
632}
633
0af11b59 634/* Add symbols listed in `filename' to strip_specific_list. */
16b2b71c
NC		 635
636#define IS_WHITESPACE(c) ((c) == ' ' || (c) == '\t')
637#define IS_LINE_TERMINATOR(c) ((c) == '\n' || (c) == '\r' || (c) == '\0')
638
639static void
84e2f313 640add_specific_symbols (const char *filename, struct symlist **list)
16b2b71c 641{
f24ddbdd 642 off_t size;
16b2b71c
NC		 643 FILE * f;
644 char * line;
645 char * buffer;
646 unsigned int line_count;
0af11b59 647
f24ddbdd
NC		 648 size = get_file_size (filename);
649 if (size == 0)
16b2b71c
NC		 650 return;
651
f24ddbdd 652 buffer = xmalloc (size + 2);
16b2b71c
NC		 653 f = fopen (filename, FOPEN_RT);
654 if (f == NULL)
f24ddbdd 655 fatal (_("cannot open '%s': %s"), filename, strerror (errno));
16b2b71c 656
f24ddbdd 657 if (fread (buffer, 1, size, f) == 0 || ferror (f))
16b2b71c
NC		 658 fatal (_("%s: fread failed"), filename);
659
660 fclose (f);
f24ddbdd
NC		 661 buffer [size] = '\n';
662 buffer [size + 1] = '\0';
16b2b71c
NC		 663
664 line_count = 1;
0af11b59 665
16b2b71c
NC		 666 for (line = buffer; * line != '\0'; line ++)
667 {
668 char * eol;
669 char * name;
670 char * name_end;
b34976b6 671 int finished = FALSE;
16b2b71c
NC		 672
673 for (eol = line;; eol ++)
674 {
675 switch (* eol)
676 {
677 case '\n':
678 * eol = '\0';
679 /* Cope with \n\r. */
680 if (eol[1] == '\r')
681 ++ eol;
b34976b6 682 finished = TRUE;
16b2b71c 683 break;
0af11b59 684
16b2b71c
NC		 685 case '\r':
686 * eol = '\0';
687 /* Cope with \r\n. */
688 if (eol[1] == '\n')
689 ++ eol;
b34976b6 690 finished = TRUE;
16b2b71c 691 break;
0af11b59 692
16b2b71c 693 case 0:
b34976b6 694 finished = TRUE;
16b2b71c 695 break;
0af11b59 696
16b2b71c
NC		 697 case '#':
698 /* Line comment, Terminate the line here, in case a
699 name is present and then allow the rest of the
700 loop to find the real end of the line. */
701 * eol = '\0';
702 break;
0af11b59 703
16b2b71c
NC		 704 default:
705 break;
706 }
707
708 if (finished)
709 break;
710 }
711
712 /* A name may now exist somewhere between 'line' and 'eol'.
713 Strip off leading whitespace and trailing whitespace,
714 then add it to the list. */
715 for (name = line; IS_WHITESPACE (* name); name ++)
716 ;
717 for (name_end = name;
718 (! IS_WHITESPACE (* name_end))
719 && (! IS_LINE_TERMINATOR (* name_end));
0af11b59
KH		 720 name_end ++)
721 ;
16b2b71c
NC		 722
723 if (! IS_LINE_TERMINATOR (* name_end))
724 {
725 char * extra;
726
727 for (extra = name_end + 1; IS_WHITESPACE (* extra); extra ++)
728 ;
729
730 if (! IS_LINE_TERMINATOR (* extra))
d412a550
NC		 731 non_fatal (_("%s:%d: Ignoring rubbish found on this line"),
732 filename, line_count);
16b2b71c 733 }
0af11b59 734
16b2b71c
NC		 735 * name_end = '\0';
736
737 if (name_end > name)
738 add_specific_symbol (name, list);
739
740 /* Advance line pointer to end of line. The 'eol ++' in the for
741 loop above will then advance us to the start of the next line. */
742 line = eol;
743 line_count ++;
744 }
745}
746
252b5132
RH		 747/* See whether a symbol should be stripped or kept based on
748 strip_specific_list and keep_symbols. */
749
b34976b6 750static bfd_boolean
84e2f313 751is_specified_symbol (const char *name, struct symlist *list)
252b5132
RH		 752{
753 struct symlist *tmp_list;
754
5fe11841
NC		 755 if (wildcard)
756 {
757 for (tmp_list = list; tmp_list; tmp_list = tmp_list->next)
758 if (*(tmp_list->name) != '!')
759 {
760 if (!fnmatch (tmp_list->name, name, 0))
761 return TRUE;
762 }
763 else
764 {
765 if (fnmatch (tmp_list->name + 1, name, 0))
766 return TRUE;
767 }
768 }
769 else
770 {
771 for (tmp_list = list; tmp_list; tmp_list = tmp_list->next)
772 if (strcmp (name, tmp_list->name) == 0)
773 return TRUE;
774 }
594ef5db 775
b34976b6 776 return FALSE;
252b5132
RH		 777}
778
779/* See if a section is being removed. */
780
b34976b6 781static bfd_boolean
84e2f313 782is_strip_section (bfd *abfd ATTRIBUTE_UNUSED, asection *sec)
252b5132 783{
2593f09a
NC		 784 if (sections_removed || sections_copied)
785 {
786 struct section_list *p;
787
788 p = find_section_list (bfd_get_section_name (abfd, sec), FALSE);
789
790 if (sections_removed && p != NULL && p->remove)
791 return TRUE;
792 if (sections_copied && (p == NULL || ! p->copy))
793 return TRUE;
794 }
252b5132 795
2593f09a
NC		 796 if ((bfd_get_section_flags (abfd, sec) & SEC_DEBUGGING) != 0)
797 {
798 if (strip_symbols == STRIP_DEBUG
252b5132
RH		 799 || strip_symbols == STRIP_UNNEEDED
800 || strip_symbols == STRIP_ALL
801 || discard_locals == LOCALS_ALL
2593f09a
NC		 802 || convert_debugging)
803 return TRUE;
ed1653a7
NC		 804
805 if (strip_symbols == STRIP_NONDEBUG)
806 return FALSE;
2593f09a 807 }
f91ea849 808
f0312d39 809 return FALSE;
252b5132
RH		 810}
811
812/* Choose which symbol entries to copy; put the result in OSYMS.
813 We don't copy in place, because that confuses the relocs.
814 Return the number of symbols to print. */
815
816static unsigned int
84e2f313
NC		 817filter_symbols (bfd *abfd, bfd *obfd, asymbol **osyms,
818 asymbol **isyms, long symcount)
252b5132 819{
84e2f313 820 asymbol **from = isyms, **to = osyms;
252b5132 821 long src_count = 0, dst_count = 0;
d8121479
L		 822 int relocatable = (abfd->flags & (HAS_RELOC | EXEC_P | DYNAMIC))
823 == HAS_RELOC;
252b5132
RH		 824
825 for (; src_count < symcount; src_count++)
826 {
827 asymbol *sym = from[src_count];
828 flagword flags = sym->flags;
d7fb0dd2 829 char *name = (char *) bfd_asymbol_name (sym);
252b5132 830 int keep;
b34976b6 831 bfd_boolean undefined;
d7fb0dd2
NC		 832 bfd_boolean rem_leading_char;
833 bfd_boolean add_leading_char;
834
835 undefined = bfd_is_und_section (bfd_get_section (sym));
252b5132 836
57938635
AM		 837 if (redefine_sym_list)
838 {
d7fb0dd2 839 char *old_name, *new_name;
57938635 840
d7fb0dd2
NC		 841 old_name = (char *) bfd_asymbol_name (sym);
842 new_name = (char *) lookup_sym_redefinition (old_name);
66491ebc
AM		 843 bfd_asymbol_name (sym) = new_name;
844 name = new_name;
57938635
AM		 845 }
846
d7fb0dd2
NC		 847 /* Check if we will remove the current leading character. */
848 rem_leading_char =
849 (name[0] == bfd_get_symbol_leading_char (abfd))
850 && (change_leading_char
851 || (remove_leading_char
852 && ((flags & (BSF_GLOBAL | BSF_WEAK)) != 0
853 || undefined
854 || bfd_is_com_section (bfd_get_section (sym)))));
855
856 /* Check if we will add a new leading character. */
857 add_leading_char =
858 change_leading_char
859 && (bfd_get_symbol_leading_char (obfd) != '\0')
860 && (bfd_get_symbol_leading_char (abfd) == '\0'
861 || (name[0] == bfd_get_symbol_leading_char (abfd)));
862
863 /* Short circuit for change_leading_char if we can do it in-place. */
864 if (rem_leading_char && add_leading_char && !prefix_symbols_string)
865 {
866 name[0] = bfd_get_symbol_leading_char (obfd);
867 bfd_asymbol_name (sym) = name;
868 rem_leading_char = FALSE;
869 add_leading_char = FALSE;
870 }
871
872 /* Remove leading char. */
873 if (rem_leading_char)
66491ebc 874 bfd_asymbol_name (sym) = ++name;
d7fb0dd2
NC		 875
876 /* Add new leading char and/or prefix. */
877 if (add_leading_char || prefix_symbols_string)
878 {
879 char *n, *ptr;
880
84e2f313
NC		 881 ptr = n = xmalloc (1 + strlen (prefix_symbols_string)
882 + strlen (name) + 1);
d7fb0dd2
NC		 883 if (add_leading_char)
884 *ptr++ = bfd_get_symbol_leading_char (obfd);
885
886 if (prefix_symbols_string)
887 {
888 strcpy (ptr, prefix_symbols_string);
889 ptr += strlen (prefix_symbols_string);
890 }
891
892 strcpy (ptr, name);
66491ebc
AM		 893 bfd_asymbol_name (sym) = n;
894 name = n;
252b5132
RH		 895 }
896
252b5132
RH		 897 if (strip_symbols == STRIP_ALL)
898 keep = 0;
899 else if ((flags & BSF_KEEP) != 0 /* Used in relocation. */
900 || ((flags & BSF_SECTION_SYM) != 0
901 && ((*bfd_get_section (sym)->symbol_ptr_ptr)->flags
902 & BSF_KEEP) != 0))
903 keep = 1;
0af11b59 904 else if (relocatable /* Relocatable file. */
d8121479
L		 905 && (flags & (BSF_GLOBAL | BSF_WEAK)) != 0)
906 keep = 1;
16b2b71c
NC		 907 else if (bfd_decode_symclass (sym) == 'I')
908 /* Global symbols in $idata sections need to be retained
b34976b6 909 even if relocatable is FALSE. External users of the
16b2b71c
NC		 910 library containing the $idata section may reference these
911 symbols. */
af3bdff7 912 keep = 1;
252b5132
RH		 913 else if ((flags & BSF_GLOBAL) != 0 /* Global symbol. */
914 || (flags & BSF_WEAK) != 0
24e01a36 915 || undefined
252b5132
RH		 916 || bfd_is_com_section (bfd_get_section (sym)))
917 keep = strip_symbols != STRIP_UNNEEDED;
918 else if ((flags & BSF_DEBUGGING) != 0) /* Debugging symbol. */
919 keep = (strip_symbols != STRIP_DEBUG
920 && strip_symbols != STRIP_UNNEEDED
921 && ! convert_debugging);
082b7297 922 else if (bfd_coff_get_comdat_section (abfd, bfd_get_section (sym)))
af3bdff7
NC		 923 /* COMDAT sections store special information in local
924 symbols, so we cannot risk stripping any of them. */
925 keep = 1;
252b5132
RH		 926 else /* Local symbol. */
927 keep = (strip_symbols != STRIP_UNNEEDED
928 && (discard_locals != LOCALS_ALL
929 && (discard_locals != LOCALS_START_L
930 || ! bfd_is_local_label (abfd, sym))));
931
932 if (keep && is_specified_symbol (name, strip_specific_list))
933 keep = 0;
bcf32829
JB		 934 if (keep
935 && !(flags & BSF_KEEP)
936 && is_specified_symbol (name, strip_unneeded_list))
937 keep = 0;
1637cd90
JB		 938 if (!keep
939 && ((keep_file_symbols && (flags & BSF_FILE))
940 || is_specified_symbol (name, keep_specific_list)))
252b5132
RH		 941 keep = 1;
942 if (keep && is_strip_section (abfd, bfd_get_section (sym)))
943 keep = 0;
e0c60db2 944
7b4a0685 945 if (keep)
252b5132 946 {
7b4a0685
NC		 947 if ((flags & BSF_GLOBAL) != 0
948 && (weaken || is_specified_symbol (name, weaken_specific_list)))
949 {
950 sym->flags &= ~ BSF_GLOBAL;
951 sym->flags |= BSF_WEAK;
952 }
252b5132 953
7b4a0685
NC		 954 if (!undefined
955 && (flags & (BSF_GLOBAL | BSF_WEAK))
956 && (is_specified_symbol (name, localize_specific_list)
957 || (keepglobal_specific_list != NULL
958 && ! is_specified_symbol (name, keepglobal_specific_list))))
959 {
960 sym->flags &= ~ (BSF_GLOBAL | BSF_WEAK);
961 sym->flags |= BSF_LOCAL;
962 }
963
964 if (!undefined
965 && (flags & BSF_LOCAL)
966 && is_specified_symbol (name, globalize_specific_list))
967 {
968 sym->flags &= ~ BSF_LOCAL;
969 sym->flags |= BSF_GLOBAL;
970 }
971
972 to[dst_count++] = sym;
973 }
252b5132
RH		 974 }
975
976 to[dst_count] = NULL;
977
978 return dst_count;
979}
980
594ef5db
NC		 981/* Find the redefined name of symbol SOURCE. */
982
57938635 983static const char *
84e2f313 984lookup_sym_redefinition (const char *source)
57938635 985{
57938635
AM		 986 struct redefine_node *list;
987
57938635 988 for (list = redefine_sym_list; list != NULL; list = list->next)
594ef5db
NC		 989 if (strcmp (source, list->source) == 0)
990 return list->target;
991
992 return source;
57938635
AM		 993}
994
594ef5db 995/* Add a node to a symbol redefine list. */
57938635
AM		 996
997static void
84e2f313 998redefine_list_append (const char *cause, const char *source, const char *target)
57938635
AM		 999{
1000 struct redefine_node **p;
1001 struct redefine_node *list;
1002 struct redefine_node *new_node;
1003
1004 for (p = &redefine_sym_list; (list = *p) != NULL; p = &list->next)
1005 {
1006 if (strcmp (source, list->source) == 0)
594ef5db 1007 fatal (_("%s: Multiple redefinition of symbol \"%s\""),
92991082 1008 cause, source);
57938635
AM		 1009
1010 if (strcmp (target, list->target) == 0)
594ef5db 1011 fatal (_("%s: Symbol \"%s\" is target of more than one redefinition"),
92991082 1012 cause, target);
57938635
AM		 1013 }
1014
d3ba0551 1015 new_node = xmalloc (sizeof (struct redefine_node));
57938635
AM		 1016
1017 new_node->source = strdup (source);
1018 new_node->target = strdup (target);
1019 new_node->next = NULL;
1020
1021 *p = new_node;
1022}
1023
92991082
JT		 1024/* Handle the --redefine-syms option. Read lines containing "old new"
1025 from the file, and add them to the symbol redefine list. */
1026
2593f09a 1027static void
84e2f313 1028add_redefine_syms_file (const char *filename)
92991082
JT		 1029{
1030 FILE *file;
1031 char *buf;
84e2f313
NC		 1032 size_t bufsize;
1033 size_t len;
1034 size_t outsym_off;
92991082
JT		 1035 int c, lineno;
1036
1037 file = fopen (filename, "r");
d3ba0551 1038 if (file == NULL)
92991082
JT		 1039 fatal (_("couldn't open symbol redefinition file %s (error: %s)"),
1040 filename, strerror (errno));
1041
1042 bufsize = 100;
d3ba0551 1043 buf = xmalloc (bufsize);
92991082
JT		 1044
1045 lineno = 1;
1046 c = getc (file);
1047 len = 0;
1048 outsym_off = 0;
1049 while (c != EOF)
1050 {
1051 /* Collect the input symbol name. */
1052 while (! IS_WHITESPACE (c) && ! IS_LINE_TERMINATOR (c) && c != EOF)
1053 {
1054 if (c == '#')
1055 goto comment;
1056 buf[len++] = c;
1057 if (len >= bufsize)
1058 {
1059 bufsize *= 2;
1060 buf = xrealloc (buf, bufsize);
1061 }
1062 c = getc (file);
1063 }
1064 buf[len++] = '\0';
1065 if (c == EOF)
1066 break;
1067
1068 /* Eat white space between the symbol names. */
1069 while (IS_WHITESPACE (c))
1070 c = getc (file);
1071 if (c == '#' || IS_LINE_TERMINATOR (c))
1072 goto comment;
1073 if (c == EOF)
1074 break;
1075
1076 /* Collect the output symbol name. */
1077 outsym_off = len;
1078 while (! IS_WHITESPACE (c) && ! IS_LINE_TERMINATOR (c) && c != EOF)
1079 {
1080 if (c == '#')
1081 goto comment;
1082 buf[len++] = c;
1083 if (len >= bufsize)
1084 {
1085 bufsize *= 2;
1086 buf = xrealloc (buf, bufsize);
1087 }
1088 c = getc (file);
1089 }
1090 buf[len++] = '\0';
1091 if (c == EOF)
1092 break;
1093
1094 /* Eat white space at end of line. */
1095 while (! IS_LINE_TERMINATOR(c) && c != EOF && IS_WHITESPACE (c))
1096 c = getc (file);
1097 if (c == '#')
1098 goto comment;
1099 /* Handle \r\n. */
1100 if ((c == '\r' && (c = getc (file)) == '\n')
1101 || c == '\n' || c == EOF)
1102 {
1103 end_of_line:
1104 /* Append the redefinition to the list. */
1105 if (buf[0] != '\0')
1106 redefine_list_append (filename, &buf[0], &buf[outsym_off]);
1107
1108 lineno++;
1109 len = 0;
1110 outsym_off = 0;
1111 if (c == EOF)
1112 break;
1113 c = getc (file);
1114 continue;
1115 }
1116 else
d412a550 1117 fatal (_("%s:%d: garbage found at end of line"), filename, lineno);
92991082
JT		 1118 comment:
1119 if (len != 0 && (outsym_off == 0 || outsym_off == len))
d412a550 1120 fatal (_("%s:%d: missing new symbol name"), filename, lineno);
92991082
JT		 1121 buf[len++] = '\0';
1122
1123 /* Eat the rest of the line and finish it. */
1124 while (c != '\n' && c != EOF)
1125 c = getc (file);
1126 goto end_of_line;
1127 }
1128
1129 if (len != 0)
d412a550 1130 fatal (_("%s:%d: premature end of file"), filename, lineno);
92991082
JT		 1131
1132 free (buf);
1133}
1134
77f762d6
L		 1135/* Copy unkown object file IBFD onto OBFD.
1136 Returns TRUE upon success, FALSE otherwise. */
1137
1138static bfd_boolean
1139copy_unknown_object (bfd *ibfd, bfd *obfd)
1140{
1141 char *cbuf;
1142 int tocopy;
1143 long ncopied;
1144 long size;
1145 struct stat buf;
1146
1147 if (bfd_stat_arch_elt (ibfd, &buf) != 0)
1148 {
1149 bfd_nonfatal (bfd_get_archive_filename (ibfd));
1150 return FALSE;
1151 }
1152
1153 size = buf.st_size;
1154 if (size < 0)
1155 {
1156 non_fatal (_("stat returns negative size for `%s'"),
1157 bfd_get_archive_filename (ibfd));
1158 return FALSE;
1159 }
1160
1161 if (bfd_seek (ibfd, (file_ptr) 0, SEEK_SET) != 0)
1162 {
1163 bfd_nonfatal (bfd_get_archive_filename (ibfd));
1164 return FALSE;
1165 }
1166
1167 if (verbose)
1168 printf (_("copy from `%s' [unknown] to `%s' [unknown]\n"),
1169 bfd_get_archive_filename (ibfd), bfd_get_filename (obfd));
1170
1171 cbuf = xmalloc (BUFSIZE);
1172 ncopied = 0;
1173 while (ncopied < size)
1174 {
1175 tocopy = size - ncopied;
1176 if (tocopy > BUFSIZE)
1177 tocopy = BUFSIZE;
1178
1179 if (bfd_bread (cbuf, (bfd_size_type) tocopy, ibfd)
1180 != (bfd_size_type) tocopy)
1181 {
1182 bfd_nonfatal (bfd_get_archive_filename (ibfd));
1183 free (cbuf);
1184 return FALSE;
1185 }
1186
1187 if (bfd_bwrite (cbuf, (bfd_size_type) tocopy, obfd)
1188 != (bfd_size_type) tocopy)
1189 {
1190 bfd_nonfatal (bfd_get_filename (obfd));
1191 free (cbuf);
1192 return FALSE;
1193 }
1194
1195 ncopied += tocopy;
1196 }
1197
1198 chmod (bfd_get_filename (obfd), buf.st_mode);
1199 free (cbuf);
1200 return TRUE;
1201}
1202
950d48e7 1203/* Copy object file IBFD onto OBFD.
5b8c74e6 1204 Returns TRUE upon success, FALSE otherwise. */
252b5132 1205
950d48e7 1206static bfd_boolean
84e2f313 1207copy_object (bfd *ibfd, bfd *obfd)
252b5132
RH		 1208{
1209 bfd_vma start;
1210 long symcount;
1211 asection **osections = NULL;
84e2f313 1212 asection *gnu_debuglink_section = NULL;
252b5132
RH		 1213 bfd_size_type *gaps = NULL;
1214 bfd_size_type max_gap = 0;
1215 long symsize;
84e2f313 1216 void *dhandle;
66491ebc
AM		 1217 enum bfd_architecture iarch;
1218 unsigned int imach;
252b5132 1219
23719f39
NC		 1220 if (ibfd->xvec->byteorder != obfd->xvec->byteorder
1221 && ibfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN
1222 && obfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN)
950d48e7 1223 fatal (_("Unable to change endianness of input file(s)"));
252b5132
RH		 1224
1225 if (!bfd_set_format (obfd, bfd_get_format (ibfd)))
950d48e7
NC		 1226 {
1227 bfd_nonfatal (bfd_get_filename (obfd));
1228 return FALSE;
1229 }
252b5132
RH		 1230
1231 if (verbose)
77f762d6
L		 1232 printf (_("copy from `%s' [%s] to `%s' [%s]\n"),
1233 bfd_get_archive_filename (ibfd), bfd_get_target (ibfd),
252b5132
RH		 1234 bfd_get_filename (obfd), bfd_get_target (obfd));
1235
1236 if (set_start_set)
1237 start = set_start;
1238 else
1239 start = bfd_get_start_address (ibfd);
1240 start += change_start;
1241
0af11b59
KH		 1242 /* Neither the start address nor the flags
1243 need to be set for a core file. */
4dd67f29
MS		 1244 if (bfd_get_format (obfd) != bfd_core)
1245 {
4087920c
MR		 1246 flagword flags;
1247
1248 flags = bfd_get_file_flags (ibfd);
1249 flags |= bfd_flags_to_set;
1250 flags &= ~bfd_flags_to_clear;
1251 flags &= bfd_applicable_file_flags (obfd);
1252
4dd67f29 1253 if (!bfd_set_start_address (obfd, start)
4087920c 1254 || !bfd_set_file_flags (obfd, flags))
950d48e7 1255 {
77f762d6 1256 bfd_nonfatal (bfd_get_archive_filename (ibfd));
950d48e7
NC		 1257 return FALSE;
1258 }
4dd67f29 1259 }
252b5132 1260
594ef5db 1261 /* Copy architecture of input file to output file. */
66491ebc
AM		 1262 iarch = bfd_get_arch (ibfd);
1263 imach = bfd_get_mach (ibfd);
1264 if (!bfd_set_arch_mach (obfd, iarch, imach)
212a3c4d
L		 1265 && (ibfd->target_defaulted
1266 || bfd_get_arch (ibfd) != bfd_get_arch (obfd)))
f57a841a
NC		 1267 {
1268 if (bfd_get_arch (ibfd) == bfd_arch_unknown)
77f762d6
L		 1269 non_fatal (_("Unable to recognise the format of the input file `%s'"),
1270 bfd_get_archive_filename (ibfd));
f57a841a 1271 else
77f762d6
L		 1272 non_fatal (_("Warning: Output file cannot represent architecture `%s'"),
1273 bfd_printable_arch_mach (bfd_get_arch (ibfd),
1274 bfd_get_mach (ibfd)));
1275 return FALSE;
f57a841a 1276 }
57938635 1277
252b5132 1278 if (!bfd_set_format (obfd, bfd_get_format (ibfd)))
950d48e7 1279 {
77f762d6 1280 bfd_nonfatal (bfd_get_archive_filename (ibfd));
950d48e7
NC		 1281 return FALSE;
1282 }
252b5132
RH		 1283
1284 if (isympp)
62d732f5 1285 free (isympp);
57938635 1286
252b5132 1287 if (osympp != isympp)
62d732f5
AM		 1288 free (osympp);
1289
1290 isympp = NULL;
1291 osympp = NULL;
252b5132
RH		 1292
1293 /* BFD mandates that all output sections be created and sizes set before
1294 any output is done. Thus, we traverse all sections multiple times. */
d3ba0551 1295 bfd_map_over_sections (ibfd, setup_section, obfd);
252b5132 1296
80fccad2
BW		 1297 setup_bfd_headers (ibfd, obfd);
1298
252b5132
RH		 1299 if (add_sections != NULL)
1300 {
1301 struct section_add *padd;
1302 struct section_list *pset;
1303
1304 for (padd = add_sections; padd != NULL; padd = padd->next)
1305 {
2593f09a
NC		 1306 flagword flags;
1307
551b43fd
AM		 1308 pset = find_section_list (padd->name, FALSE);
1309 if (pset != NULL)
1310 pset->used = TRUE;
1311
1312 flags = SEC_HAS_CONTENTS | SEC_READONLY | SEC_DATA;
1313 if (pset != NULL && pset->set_flags)
1314 flags = pset->flags | SEC_HAS_CONTENTS;
1315
c8782eee
NC		 1316 /* bfd_make_section_with_flags() does not return very helpful
1317 error codes, so check for the most likely user error first. */
1318 if (bfd_get_section_by_name (obfd, padd->name))
252b5132 1319 {
c8782eee 1320 non_fatal (_("can't add section '%s' - it already exists!"), padd->name);
950d48e7 1321 return FALSE;
252b5132 1322 }
c8782eee
NC		 1323 else
1324 {
1325 padd->section = bfd_make_section_with_flags (obfd, padd->name, flags);
1326 if (padd->section == NULL)
1327 {
1328 non_fatal (_("can't create section `%s': %s"),
1329 padd->name, bfd_errmsg (bfd_get_error ()));
1330 return FALSE;
1331 }
1332 }
252b5132 1333
2593f09a 1334 if (! bfd_set_section_size (obfd, padd->section, padd->size))
950d48e7
NC		 1335 {
1336 bfd_nonfatal (bfd_get_filename (obfd));
1337 return FALSE;
1338 }
252b5132 1339
2593f09a
NC		 1340 if (pset != NULL)
1341 {
1342 if (pset->change_vma != CHANGE_IGNORE)
84e2f313
NC		 1343 if (! bfd_set_section_vma (obfd, padd->section,
1344 pset->vma_val))
950d48e7
NC		 1345 {
1346 bfd_nonfatal (bfd_get_filename (obfd));
1347 return FALSE;
1348 }
57938635 1349
2593f09a
NC		 1350 if (pset->change_lma != CHANGE_IGNORE)
1351 {
1352 padd->section->lma = pset->lma_val;
950d48e7 1353
2593f09a
NC		 1354 if (! bfd_set_section_alignment
1355 (obfd, padd->section,
1356 bfd_section_alignment (obfd, padd->section)))
950d48e7
NC		 1357 {
1358 bfd_nonfatal (bfd_get_filename (obfd));
1359 return FALSE;
1360 }
252b5132
RH		 1361 }
1362 }
1363 }
1364 }
1365
2593f09a
NC		 1366 if (gnu_debuglink_filename != NULL)
1367 {
84e2f313
NC		 1368 gnu_debuglink_section = bfd_create_gnu_debuglink_section
1369 (obfd, gnu_debuglink_filename);
e7c81c25
NC		 1370
1371 if (gnu_debuglink_section == NULL)
950d48e7
NC		 1372 {
1373 bfd_nonfatal (gnu_debuglink_filename);
1374 return FALSE;
1375 }
6e2c86ac
NC		 1376
1377 /* Special processing for PE format files. We
1378 have no way to distinguish PE from COFF here. */
1379 if (bfd_get_flavour (obfd) == bfd_target_coff_flavour)
1380 {
1381 bfd_vma debuglink_vma;
1382 asection * highest_section;
1383 asection * sec;
1384
1385 /* The PE spec requires that all sections be adjacent and sorted
1386 in ascending order of VMA. It also specifies that debug
1387 sections should be last. This is despite the fact that debug
1388 sections are not loaded into memory and so in theory have no
1389 use for a VMA.
1390
1391 This means that the debuglink section must be given a non-zero
1392 VMA which makes it contiguous with other debug sections. So
1393 walk the current section list, find the section with the
1394 highest VMA and start the debuglink section after that one. */
1395 for (sec = obfd->sections, highest_section = NULL;
1396 sec != NULL;
1397 sec = sec->next)
1398 if (sec->vma > 0
1399 && (highest_section == NULL
1400 || sec->vma > highest_section->vma))
1401 highest_section = sec;
1402
1403 if (highest_section)
1404 debuglink_vma = BFD_ALIGN (highest_section->vma
1405 + highest_section->size,
1406 /* FIXME: We ought to be using
1407 COFF_PAGE_SIZE here or maybe
1408 bfd_get_section_alignment() (if it
1409 was set) but since this is for PE
1410 and we know the required alignment
1411 it is easier just to hard code it. */
1412 0x1000);
1413 else
1414 /* Umm, not sure what to do in this case. */
1415 debuglink_vma = 0x1000;
1416
1417 bfd_set_section_vma (obfd, gnu_debuglink_section, debuglink_vma);
1418 }
950d48e7
NC		 1419 }
1420
1421 if (bfd_count_sections (obfd) == 0)
1422 {
1423 non_fatal (_("there are no sections to be copied!"));
1424 return FALSE;
2593f09a
NC		 1425 }
1426
252b5132
RH		 1427 if (gap_fill_set || pad_to_set)
1428 {
1429 asection **set;
1430 unsigned int c, i;
1431
1432 /* We must fill in gaps between the sections and/or we must pad
1433 the last section to a specified address. We do this by
1434 grabbing a list of the sections, sorting them by VMA, and
1435 increasing the section sizes as required to fill the gaps.
1436 We write out the gap contents below. */
1437
1438 c = bfd_count_sections (obfd);
d3ba0551 1439 osections = xmalloc (c * sizeof (asection *));
252b5132 1440 set = osections;
d3ba0551 1441 bfd_map_over_sections (obfd, get_sections, &set);
252b5132
RH		 1442
1443 qsort (osections, c, sizeof (asection *), compare_section_lma);
1444
d3ba0551 1445 gaps = xmalloc (c * sizeof (bfd_size_type));
252b5132
RH		 1446 memset (gaps, 0, c * sizeof (bfd_size_type));
1447
1448 if (gap_fill_set)
1449 {
1450 for (i = 0; i < c - 1; i++)
1451 {
1452 flagword flags;
1453 bfd_size_type size;
1454 bfd_vma gap_start, gap_stop;
1455
1456 flags = bfd_get_section_flags (obfd, osections[i]);
1457 if ((flags & SEC_HAS_CONTENTS) == 0
1458 || (flags & SEC_LOAD) == 0)
1459 continue;
1460
1461 size = bfd_section_size (obfd, osections[i]);
1462 gap_start = bfd_section_lma (obfd, osections[i]) + size;
1463 gap_stop = bfd_section_lma (obfd, osections[i + 1]);
1464 if (gap_start < gap_stop)
1465 {
1466 if (! bfd_set_section_size (obfd, osections[i],
1467 size + (gap_stop - gap_start)))
1468 {
1469 non_fatal (_("Can't fill gap after %s: %s"),
0af11b59
KH		 1470 bfd_get_section_name (obfd, osections[i]),
1471 bfd_errmsg (bfd_get_error ()));
252b5132
RH		 1472 status = 1;
1473 break;
1474 }
1475 gaps[i] = gap_stop - gap_start;
1476 if (max_gap < gap_stop - gap_start)
1477 max_gap = gap_stop - gap_start;
1478 }
1479 }
1480 }
1481
1482 if (pad_to_set)
1483 {
1484 bfd_vma lma;
1485 bfd_size_type size;
1486
1487 lma = bfd_section_lma (obfd, osections[c - 1]);
1488 size = bfd_section_size (obfd, osections[c - 1]);
1489 if (lma + size < pad_to)
1490 {
1491 if (! bfd_set_section_size (obfd, osections[c - 1],
1492 pad_to - lma))
1493 {
1494 non_fatal (_("Can't add padding to %s: %s"),
0af11b59
KH		 1495 bfd_get_section_name (obfd, osections[c - 1]),
1496 bfd_errmsg (bfd_get_error ()));
252b5132
RH		 1497 status = 1;
1498 }
1499 else
1500 {
1501 gaps[c - 1] = pad_to - (lma + size);
1502 if (max_gap < pad_to - (lma + size))
1503 max_gap = pad_to - (lma + size);
1504 }
1505 }
1506 }
1507 }
1508
594ef5db
NC		 1509 /* Symbol filtering must happen after the output sections
1510 have been created, but before their contents are set. */
252b5132
RH		 1511 dhandle = NULL;
1512 symsize = bfd_get_symtab_upper_bound (ibfd);
1513 if (symsize < 0)
950d48e7 1514 {
77f762d6 1515 bfd_nonfatal (bfd_get_archive_filename (ibfd));
950d48e7
NC		 1516 return FALSE;
1517 }
57938635 1518
d3ba0551 1519 osympp = isympp = xmalloc (symsize);
252b5132
RH		 1520 symcount = bfd_canonicalize_symtab (ibfd, isympp);
1521 if (symcount < 0)
950d48e7
NC		 1522 {
1523 bfd_nonfatal (bfd_get_filename (ibfd));
1524 return FALSE;
1525 }
57938635 1526
252b5132
RH		 1527 if (convert_debugging)
1528 dhandle = read_debugging_info (ibfd, isympp, symcount);
57938635
AM		 1529
1530 if (strip_symbols == STRIP_DEBUG
252b5132
RH		 1531 || strip_symbols == STRIP_ALL
1532 || strip_symbols == STRIP_UNNEEDED
ed1653a7 1533 || strip_symbols == STRIP_NONDEBUG
252b5132
RH		 1534 || discard_locals != LOCALS_UNDEF
1535 || strip_specific_list != NULL
1536 || keep_specific_list != NULL
1537 || localize_specific_list != NULL
7b4a0685 1538 || globalize_specific_list != NULL
16b2b71c 1539 || keepglobal_specific_list != NULL
252b5132 1540 || weaken_specific_list != NULL
d7fb0dd2 1541 || prefix_symbols_string
252b5132 1542 || sections_removed
f91ea849 1543 || sections_copied
252b5132
RH		 1544 || convert_debugging
1545 || change_leading_char
1546 || remove_leading_char
57938635 1547 || redefine_sym_list
252b5132
RH		 1548 || weaken)
1549 {
1550 /* Mark symbols used in output relocations so that they
1551 are kept, even if they are local labels or static symbols.
57938635 1552
252b5132
RH		 1553 Note we iterate over the input sections examining their
1554 relocations since the relocations for the output sections
1555 haven't been set yet. mark_symbols_used_in_relocations will
1556 ignore input sections which have no corresponding output
1557 section. */
1558 if (strip_symbols != STRIP_ALL)
1559 bfd_map_over_sections (ibfd,
1560 mark_symbols_used_in_relocations,
d3ba0551
AM		 1561 isympp);
1562 osympp = xmalloc ((symcount + 1) * sizeof (asymbol *));
252b5132
RH		 1563 symcount = filter_symbols (ibfd, obfd, osympp, isympp, symcount);
1564 }
1565
1566 if (convert_debugging && dhandle != NULL)
1567 {
1568 if (! write_debugging_info (obfd, dhandle, &symcount, &osympp))
1569 {
1570 status = 1;
950d48e7 1571 return FALSE;
252b5132
RH		 1572 }
1573 }
1574
1575 bfd_set_symtab (obfd, osympp, symcount);
1576
1577 /* This has to happen after the symbol table has been set. */
d3ba0551 1578 bfd_map_over_sections (ibfd, copy_section, obfd);
252b5132
RH		 1579
1580 if (add_sections != NULL)
1581 {
1582 struct section_add *padd;
1583
1584 for (padd = add_sections; padd != NULL; padd = padd->next)
1585 {
d3ba0551
AM		 1586 if (! bfd_set_section_contents (obfd, padd->section, padd->contents,
1587 0, padd->size))
950d48e7
NC		 1588 {
1589 bfd_nonfatal (bfd_get_filename (obfd));
1590 return FALSE;
1591 }
252b5132
RH		 1592 }
1593 }
1594
e7c81c25
NC		 1595 if (gnu_debuglink_filename != NULL)
1596 {
1597 if (! bfd_fill_in_gnu_debuglink_section
1598 (obfd, gnu_debuglink_section, gnu_debuglink_filename))
950d48e7
NC		 1599 {
1600 bfd_nonfatal (gnu_debuglink_filename);
1601 return FALSE;
1602 }
e7c81c25
NC		 1603 }
1604
252b5132
RH		 1605 if (gap_fill_set || pad_to_set)
1606 {
1607 bfd_byte *buf;
1608 int c, i;
1609
1610 /* Fill in the gaps. */
252b5132
RH		 1611 if (max_gap > 8192)
1612 max_gap = 8192;
d3ba0551
AM		 1613 buf = xmalloc (max_gap);
1614 memset (buf, gap_fill, max_gap);
252b5132
RH		 1615
1616 c = bfd_count_sections (obfd);
1617 for (i = 0; i < c; i++)
1618 {
1619 if (gaps[i] != 0)
1620 {
1621 bfd_size_type left;
1622 file_ptr off;
1623
1624 left = gaps[i];
1625 off = bfd_section_size (obfd, osections[i]) - left;
594ef5db 1626
252b5132
RH		 1627 while (left > 0)
1628 {
1629 bfd_size_type now;
1630
1631 if (left > 8192)
1632 now = 8192;
1633 else
1634 now = left;
1635
1636 if (! bfd_set_section_contents (obfd, osections[i], buf,
1637 off, now))
950d48e7
NC		 1638 {
1639 bfd_nonfatal (bfd_get_filename (obfd));
1640 return FALSE;
1641 }
252b5132
RH		 1642
1643 left -= now;
1644 off += now;
1645 }
1646 }
1647 }
1648 }
1649
1650 /* Allow the BFD backend to copy any private data it understands
1651 from the input BFD to the output BFD. This is done last to
1652 permit the routine to look at the filtered symbol table, which is
1653 important for the ECOFF code at least. */
ed1653a7
NC		 1654 if (bfd_get_flavour (ibfd) == bfd_target_elf_flavour
1655 && strip_symbols == STRIP_NONDEBUG)
1656 /* Do not copy the private data when creating an ELF format
1657 debug info file. We do not want the program headers. */
1658 ;
1659 else if (! bfd_copy_private_bfd_data (ibfd, obfd))
252b5132
RH		 1660 {
1661 non_fatal (_("%s: error copying private BFD data: %s"),
1662 bfd_get_filename (obfd),
1663 bfd_errmsg (bfd_get_error ()));
950d48e7 1664 return FALSE;
252b5132 1665 }
1ae8b3d2
AO		 1666
1667 /* Switch to the alternate machine code. We have to do this at the
1668 very end, because we only initialize the header when we create
1669 the first section. */
950d48e7
NC		 1670 if (use_alt_mach_code != 0
1671 && ! bfd_alt_mach_code (obfd, use_alt_mach_code))
1672 non_fatal (_("unknown alternate machine code, ignored"));
1673
1674 return TRUE;
252b5132
RH		 1675}
1676
4c168fa3
AM		 1677#undef MKDIR
1678#if defined (_WIN32) && !defined (__CYGWIN32__)
1679#define MKDIR(DIR, MODE) mkdir (DIR)
1680#else
1681#define MKDIR(DIR, MODE) mkdir (DIR, MODE)
1682#endif
1683
252b5132
RH		 1684/* Read each archive element in turn from IBFD, copy the
1685 contents to temp file, and keep the temp file handle. */
1686
1687static void
84e2f313 1688copy_archive (bfd *ibfd, bfd *obfd, const char *output_target)
252b5132
RH		 1689{
1690 struct name_list
1691 {
1692 struct name_list *next;
4c168fa3 1693 const char *name;
252b5132
RH		 1694 bfd *obfd;
1695 } *list, *l;
1696 bfd **ptr = &obfd->archive_head;
1697 bfd *this_element;
1698 char *dir = make_tempname (bfd_get_filename (obfd));
1699
1700 /* Make a temp directory to hold the contents. */
4c168fa3 1701 if (MKDIR (dir, 0700) != 0)
84e2f313
NC		 1702 fatal (_("cannot mkdir %s for archive copying (error: %s)"),
1703 dir, strerror (errno));
1704
252b5132
RH		 1705 obfd->has_armap = ibfd->has_armap;
1706
1707 list = NULL;
1708
1709 this_element = bfd_openr_next_archived_file (ibfd, NULL);
594ef5db 1710
b667df2e
AM		 1711 if (!bfd_set_format (obfd, bfd_get_format (ibfd)))
1712 RETURN_NONFATAL (bfd_get_filename (obfd));
1713
d3ba0551 1714 while (!status && this_element != NULL)
252b5132 1715 {
4c168fa3
AM		 1716 char *output_name;
1717 bfd *output_bfd;
252b5132 1718 bfd *last_element;
8066d1a2
AS		 1719 struct stat buf;
1720 int stat_status = 0;
950d48e7 1721 bfd_boolean delete = TRUE;
8066d1a2 1722
4c168fa3
AM		 1723 /* Create an output file for this member. */
1724 output_name = concat (dir, "/",
1725 bfd_get_filename (this_element), (char *) 0);
1726
1727 /* If the file already exists, make another temp dir. */
1728 if (stat (output_name, &buf) >= 0)
1729 {
1730 output_name = make_tempname (output_name);
1731 if (MKDIR (output_name, 0700) != 0)
84e2f313
NC		 1732 fatal (_("cannot mkdir %s for archive copying (error: %s)"),
1733 output_name, strerror (errno));
1734
d3ba0551 1735 l = xmalloc (sizeof (struct name_list));
4c168fa3
AM		 1736 l->name = output_name;
1737 l->next = list;
1738 l->obfd = NULL;
1739 list = l;
1740 output_name = concat (output_name, "/",
1741 bfd_get_filename (this_element), (char *) 0);
1742 }
1743
1744 output_bfd = bfd_openw (output_name, output_target);
8066d1a2
AS		 1745 if (preserve_dates)
1746 {
1747 stat_status = bfd_stat_arch_elt (this_element, &buf);
594ef5db 1748
8066d1a2
AS		 1749 if (stat_status != 0)
1750 non_fatal (_("internal stat error on %s"),
1751 bfd_get_filename (this_element));
1752 }
252b5132 1753
d3ba0551 1754 l = xmalloc (sizeof (struct name_list));
252b5132
RH		 1755 l->name = output_name;
1756 l->next = list;
bee59fd2 1757 l->obfd = NULL;
252b5132
RH		 1758 list = l;
1759
d3ba0551 1760 if (output_bfd == NULL)
252b5132
RH		 1761 RETURN_NONFATAL (output_name);
1762
b34976b6 1763 if (bfd_check_format (this_element, bfd_object))
77f762d6
L		 1764 {
1765 delete = ! copy_object (this_element, output_bfd);
252b5132 1766
77f762d6
L		 1767 if (! delete
1768 || bfd_get_arch (this_element) != bfd_arch_unknown)
1769 {
1770 if (!bfd_close (output_bfd))
1771 {
1772 bfd_nonfatal (bfd_get_filename (output_bfd));
1773 /* Error in new object file. Don't change archive. */
1774 status = 1;
1775 }
1776 }
1777 else
1778 goto copy_unknown_element;
1779 }
1780 else
252b5132 1781 {
77f762d6
L		 1782 non_fatal (_("Unable to recognise the format of the input file `%s'"),
1783 bfd_get_archive_filename (this_element));
1784
1785copy_unknown_element:
1786 delete = !copy_unknown_object (this_element, output_bfd);
1787 if (!bfd_close_all_done (output_bfd))
1788 {
1789 bfd_nonfatal (bfd_get_filename (output_bfd));
1790 /* Error in new object file. Don't change archive. */
1791 status = 1;
1792 }
252b5132
RH		 1793 }
1794
950d48e7
NC		 1795 if (delete)
1796 {
1797 unlink (output_name);
1798 status = 1;
1799 }
1800 else
1801 {
1802 if (preserve_dates && stat_status == 0)
1803 set_times (output_name, &buf);
8066d1a2 1804
950d48e7
NC		 1805 /* Open the newly output file and attach to our list. */
1806 output_bfd = bfd_openr (output_name, output_target);
252b5132 1807
950d48e7 1808 l->obfd = output_bfd;
252b5132 1809
950d48e7
NC		 1810 *ptr = output_bfd;
1811 ptr = &output_bfd->next;
252b5132 1812
950d48e7 1813 last_element = this_element;
252b5132 1814
950d48e7 1815 this_element = bfd_openr_next_archived_file (ibfd, last_element);
252b5132 1816
950d48e7
NC		 1817 bfd_close (last_element);
1818 }
252b5132 1819 }
d3ba0551 1820 *ptr = NULL;
252b5132
RH		 1821
1822 if (!bfd_close (obfd))
1823 RETURN_NONFATAL (bfd_get_filename (obfd));
1824
1825 if (!bfd_close (ibfd))
1826 RETURN_NONFATAL (bfd_get_filename (ibfd));
1827
1828 /* Delete all the files that we opened. */
1829 for (l = list; l != NULL; l = l->next)
1830 {
4c168fa3
AM		 1831 if (l->obfd == NULL)
1832 rmdir (l->name);
1833 else
1834 {
1835 bfd_close (l->obfd);
1836 unlink (l->name);
1837 }
252b5132
RH		 1838 }
1839 rmdir (dir);
1840}
1841
1842/* The top-level control. */
1843
1844static void
84e2f313
NC		 1845copy_file (const char *input_filename, const char *output_filename,
1846 const char *input_target, const char *output_target)
252b5132
RH		 1847{
1848 bfd *ibfd;
49c12576
AM		 1849 char **obj_matching;
1850 char **core_matching;
252b5132 1851
f24ddbdd
NC		 1852 if (get_file_size (input_filename) < 1)
1853 {
ac559f4a 1854 non_fatal (_("error: the input file '%s' is empty"), input_filename);
f24ddbdd
NC		 1855 status = 1;
1856 return;
1857 }
1858
252b5132
RH		 1859 /* To allow us to do "strip *" without dying on the first
1860 non-object file, failures are nonfatal. */
252b5132
RH		 1861 ibfd = bfd_openr (input_filename, input_target);
1862 if (ibfd == NULL)
1863 RETURN_NONFATAL (input_filename);
1864
1865 if (bfd_check_format (ibfd, bfd_archive))
1866 {
1867 bfd *obfd;
1868
1869 /* bfd_get_target does not return the correct value until
1870 bfd_check_format succeeds. */
1871 if (output_target == NULL)
1872 output_target = bfd_get_target (ibfd);
1873
1874 obfd = bfd_openw (output_filename, output_target);
1875 if (obfd == NULL)
1876 RETURN_NONFATAL (output_filename);
1877
1878 copy_archive (ibfd, obfd, output_target);
1879 }
49c12576 1880 else if (bfd_check_format_matches (ibfd, bfd_object, &obj_matching))
252b5132
RH		 1881 {
1882 bfd *obfd;
49c12576 1883 do_copy:
950d48e7 1884
252b5132
RH		 1885 /* bfd_get_target does not return the correct value until
1886 bfd_check_format succeeds. */
1887 if (output_target == NULL)
1888 output_target = bfd_get_target (ibfd);
1889
1890 obfd = bfd_openw (output_filename, output_target);
1891 if (obfd == NULL)
1892 RETURN_NONFATAL (output_filename);
1893
a580b8e0
JB		 1894 if (! copy_object (ibfd, obfd))
1895 status = 1;
252b5132
RH		 1896
1897 if (!bfd_close (obfd))
1898 RETURN_NONFATAL (output_filename);
1899
1900 if (!bfd_close (ibfd))
1901 RETURN_NONFATAL (input_filename);
950d48e7 1902
252b5132
RH		 1903 }
1904 else
1905 {
49c12576
AM		 1906 bfd_error_type obj_error = bfd_get_error ();
1907 bfd_error_type core_error;
b34976b6 1908
49c12576
AM		 1909 if (bfd_check_format_matches (ibfd, bfd_core, &core_matching))
1910 {
1911 /* This probably can't happen.. */
1912 if (obj_error == bfd_error_file_ambiguously_recognized)
1913 free (obj_matching);
1914 goto do_copy;
1915 }
1916
1917 core_error = bfd_get_error ();
1918 /* Report the object error in preference to the core error. */
1919 if (obj_error != core_error)
1920 bfd_set_error (obj_error);
1921
252b5132 1922 bfd_nonfatal (input_filename);
57938635 1923
49c12576
AM		 1924 if (obj_error == bfd_error_file_ambiguously_recognized)
1925 {
1926 list_matching_formats (obj_matching);
1927 free (obj_matching);
1928 }
1929 if (core_error == bfd_error_file_ambiguously_recognized)
252b5132 1930 {
49c12576
AM		 1931 list_matching_formats (core_matching);
1932 free (core_matching);
252b5132 1933 }
57938635 1934
252b5132
RH		 1935 status = 1;
1936 }
1937}
1938
594ef5db
NC		 1939/* Add a name to the section renaming list. */
1940
1941static void
84e2f313
NC		 1942add_section_rename (const char * old_name, const char * new_name,
1943 flagword flags)
594ef5db
NC		 1944{
1945 section_rename * rename;
1946
1947 /* Check for conflicts first. */
1948 for (rename = section_rename_list; rename != NULL; rename = rename->next)
1949 if (strcmp (rename->old_name, old_name) == 0)
1950 {
1951 /* Silently ignore duplicate definitions. */
1952 if (strcmp (rename->new_name, new_name) == 0
1953 && rename->flags == flags)
1954 return;
0af11b59 1955
594ef5db
NC		 1956 fatal (_("Multiple renames of section %s"), old_name);
1957 }
1958
d3ba0551 1959 rename = xmalloc (sizeof (* rename));
594ef5db
NC		 1960
1961 rename->old_name = old_name;
1962 rename->new_name = new_name;
1963 rename->flags = flags;
1964 rename->next = section_rename_list;
0af11b59 1965
594ef5db
NC		 1966 section_rename_list = rename;
1967}
1968
1969/* Check the section rename list for a new name of the input section
1970 ISECTION. Return the new name if one is found.
1971 Also set RETURNED_FLAGS to the flags to be used for this section. */
1972
1973static const char *
84e2f313
NC		 1974find_section_rename (bfd * ibfd ATTRIBUTE_UNUSED, sec_ptr isection,
1975 flagword * returned_flags)
594ef5db
NC		 1976{
1977 const char * old_name = bfd_section_name (ibfd, isection);
1978 section_rename * rename;
1979
1980 /* Default to using the flags of the input section. */
1981 * returned_flags = bfd_get_section_flags (ibfd, isection);
1982
1983 for (rename = section_rename_list; rename != NULL; rename = rename->next)
1984 if (strcmp (rename->old_name, old_name) == 0)
1985 {
1986 if (rename->flags != (flagword) -1)
1987 * returned_flags = rename->flags;
1988
1989 return rename->new_name;
1990 }
1991
1992 return old_name;
1993}
1994
80fccad2
BW		 1995/* Once each of the sections is copied, we may still need to do some
1996 finalization work for private section headers. Do that here. */
1997
1998static void
1999setup_bfd_headers (bfd *ibfd, bfd *obfd)
2000{
2001 const char *err;
2002
2003 /* Allow the BFD backend to copy any private data it understands
2004 from the input section to the output section. */
2005 if (! bfd_copy_private_header_data (ibfd, obfd))
2006 {
2007 err = _("private header data");
2008 goto loser;
2009 }
2010
2011 /* All went well. */
2012 return;
2013
2014loser:
2015 non_fatal (_("%s: error in %s: %s"),
2016 bfd_get_filename (ibfd),
2017 err, bfd_errmsg (bfd_get_error ()));
2018 status = 1;
2019}
2020
594ef5db
NC		 2021/* Create a section in OBFD with the same
2022 name and attributes as ISECTION in IBFD. */
252b5132
RH		 2023
2024static void
84e2f313 2025setup_section (bfd *ibfd, sec_ptr isection, void *obfdarg)
252b5132 2026{
d3ba0551 2027 bfd *obfd = obfdarg;
252b5132
RH		 2028 struct section_list *p;
2029 sec_ptr osection;
2030 bfd_size_type size;
2031 bfd_vma vma;
2032 bfd_vma lma;
2033 flagword flags;
1a89cc7d 2034 const char *err;
594ef5db 2035 const char * name;
d7fb0dd2 2036 char *prefix = NULL;
0af11b59 2037
2593f09a 2038 if (is_strip_section (ibfd, isection))
252b5132
RH		 2039 return;
2040
b34976b6 2041 p = find_section_list (bfd_section_name (ibfd, isection), FALSE);
252b5132 2042 if (p != NULL)
b34976b6 2043 p->used = TRUE;
252b5132 2044
594ef5db
NC		 2045 /* Get the, possibly new, name of the output section. */
2046 name = find_section_rename (ibfd, isection, & flags);
0af11b59 2047
d7fb0dd2 2048 /* Prefix sections. */
84e2f313
NC		 2049 if ((prefix_alloc_sections_string)
2050 && (bfd_get_section_flags (ibfd, isection) & SEC_ALLOC))
d7fb0dd2
NC		 2051 prefix = prefix_alloc_sections_string;
2052 else if (prefix_sections_string)
2053 prefix = prefix_sections_string;
2054
2055 if (prefix)
2056 {
2057 char *n;
2058
2059 n = xmalloc (strlen (prefix) + strlen (name) + 1);
2060 strcpy (n, prefix);
2061 strcat (n, name);
2062 name = n;
2063 }
66491ebc 2064
551b43fd
AM		 2065 if (p != NULL && p->set_flags)
2066 flags = p->flags | (flags & (SEC_HAS_CONTENTS | SEC_RELOC));
2067 else if (strip_symbols == STRIP_NONDEBUG && (flags & SEC_ALLOC) != 0)
2068 flags &= ~(SEC_HAS_CONTENTS | SEC_LOAD);
2069
2070 osection = bfd_make_section_anyway_with_flags (obfd, name, flags);
57938635 2071
252b5132
RH		 2072 if (osection == NULL)
2073 {
1a89cc7d 2074 err = _("making");
252b5132
RH		 2075 goto loser;
2076 }
2077
551b43fd
AM		 2078 if (strip_symbols == STRIP_NONDEBUG
2079 && obfd->xvec->flavour == bfd_target_elf_flavour
2080 && (flags & SEC_ALLOC) != 0
2081 && (p == NULL || !p->set_flags))
2082 elf_section_type (osection) = SHT_NOBITS;
2083
252b5132
RH		 2084 size = bfd_section_size (ibfd, isection);
2085 if (copy_byte >= 0)
2086 size = (size + interleave - 1) / interleave;
2087 if (! bfd_set_section_size (obfd, osection, size))
2088 {
1a89cc7d 2089 err = _("size");
252b5132
RH		 2090 goto loser;
2091 }
57938635 2092
252b5132
RH		 2093 vma = bfd_section_vma (ibfd, isection);
2094 if (p != NULL && p->change_vma == CHANGE_MODIFY)
2095 vma += p->vma_val;
2096 else if (p != NULL && p->change_vma == CHANGE_SET)
2097 vma = p->vma_val;
2098 else
2099 vma += change_section_address;
57938635 2100
252b5132
RH		 2101 if (! bfd_set_section_vma (obfd, osection, vma))
2102 {
1a89cc7d 2103 err = _("vma");
252b5132
RH		 2104 goto loser;
2105 }
2106
2107 lma = isection->lma;
2108 if ((p != NULL) && p->change_lma != CHANGE_IGNORE)
2109 {
2110 if (p->change_lma == CHANGE_MODIFY)
2111 lma += p->lma_val;
2112 else if (p->change_lma == CHANGE_SET)
2113 lma = p->lma_val;
2114 else
2115 abort ();
2116 }
2117 else
2118 lma += change_section_address;
57938635 2119
252b5132
RH		 2120 osection->lma = lma;
2121
2122 /* FIXME: This is probably not enough. If we change the LMA we
2123 may have to recompute the header for the file as well. */
b34976b6
AM		 2124 if (!bfd_set_section_alignment (obfd,
2125 osection,
2126 bfd_section_alignment (ibfd, isection)))
252b5132 2127 {
1a89cc7d 2128 err = _("alignment");
252b5132
RH		 2129 goto loser;
2130 }
2131
bc408b8a
JJ		 2132 /* Copy merge entity size. */
2133 osection->entsize = isection->entsize;
2134
252b5132
RH		 2135 /* This used to be mangle_section; we do here to avoid using
2136 bfd_get_section_by_name since some formats allow multiple
2137 sections with the same name. */
2138 isection->output_section = osection;
2139 isection->output_offset = 0;
2140
2141 /* Allow the BFD backend to copy any private data it understands
2142 from the input section to the output section. */
ed1653a7
NC		 2143 if (bfd_get_flavour (ibfd) == bfd_target_elf_flavour
2144 && strip_symbols == STRIP_NONDEBUG)
2145 /* Do not copy the private data when creating an ELF format
2146 debug info file. We do not want the program headers. */
2147 ;
2148 else if (!bfd_copy_private_section_data (ibfd, isection, obfd, osection))
252b5132 2149 {
1a89cc7d 2150 err = _("private data");
252b5132
RH		 2151 goto loser;
2152 }
2153
594ef5db 2154 /* All went well. */
252b5132
RH		 2155 return;
2156
2157loser:
2158 non_fatal (_("%s: section `%s': error in %s: %s"),
2159 bfd_get_filename (ibfd),
2160 bfd_section_name (ibfd, isection),
2161 err, bfd_errmsg (bfd_get_error ()));
2162 status = 1;
2163}
2164
2165/* Copy the data of input section ISECTION of IBFD
2166 to an output section with the same name in OBFD.
2167 If stripping then don't copy any relocation info. */
2168
2169static void
84e2f313 2170copy_section (bfd *ibfd, sec_ptr isection, void *obfdarg)
252b5132 2171{
d3ba0551 2172 bfd *obfd = obfdarg;
252b5132
RH		 2173 struct section_list *p;
2174 arelent **relpp;
2175 long relcount;
2176 sec_ptr osection;
2177 bfd_size_type size;
2178 long relsize;
dc156bc0 2179 flagword flags;
252b5132 2180
594ef5db
NC		 2181 /* If we have already failed earlier on,
2182 do not keep on generating complaints now. */
252b5132
RH		 2183 if (status != 0)
2184 return;
57938635 2185
2593f09a 2186 if (is_strip_section (ibfd, isection))
e0c60db2 2187 return;
252b5132 2188
2593f09a 2189 flags = bfd_get_section_flags (ibfd, isection);
dc156bc0
AM		 2190 if ((flags & SEC_GROUP) != 0)
2191 return;
2192
252b5132 2193 osection = isection->output_section;
135dfb4a 2194 size = bfd_get_section_size (isection);
252b5132
RH		 2195
2196 if (size == 0 || osection == 0)
2197 return;
2198
2593f09a
NC		 2199 p = find_section_list (bfd_get_section_name (ibfd, isection), FALSE);
2200
0af11b59 2201 /* Core files do not need to be relocated. */
4dd67f29
MS		 2202 if (bfd_get_format (obfd) == bfd_core)
2203 relsize = 0;
2204 else
ed570f48
NC		 2205 {
2206 relsize = bfd_get_reloc_upper_bound (ibfd, isection);
4dd67f29 2207
ed570f48
NC		 2208 if (relsize < 0)
2209 {
2210 /* Do not complain if the target does not support relocations. */
2211 if (relsize == -1 && bfd_get_error () == bfd_error_invalid_operation)
2212 relsize = 0;
2213 else
2214 RETURN_NONFATAL (bfd_get_filename (ibfd));
2215 }
2216 }
57938635 2217
252b5132 2218 if (relsize == 0)
d3ba0551 2219 bfd_set_reloc (obfd, osection, NULL, 0);
252b5132
RH		 2220 else
2221 {
d3ba0551 2222 relpp = xmalloc (relsize);
252b5132
RH		 2223 relcount = bfd_canonicalize_reloc (ibfd, isection, relpp, isympp);
2224 if (relcount < 0)
2225 RETURN_NONFATAL (bfd_get_filename (ibfd));
57938635 2226
252b5132
RH		 2227 if (strip_symbols == STRIP_ALL)
2228 {
2229 /* Remove relocations which are not in
0af11b59 2230 keep_strip_specific_list. */
252b5132
RH		 2231 arelent **temp_relpp;
2232 long temp_relcount = 0;
2233 long i;
57938635 2234
d3ba0551 2235 temp_relpp = xmalloc (relsize);
252b5132 2236 for (i = 0; i < relcount; i++)
d3ba0551
AM		 2237 if (is_specified_symbol (bfd_asymbol_name (*relpp[i]->sym_ptr_ptr),
2238 keep_specific_list))
252b5132
RH		 2239 temp_relpp [temp_relcount++] = relpp [i];
2240 relcount = temp_relcount;
2241 free (relpp);
2242 relpp = temp_relpp;
2243 }
e0c60db2 2244
d3ba0551 2245 bfd_set_reloc (obfd, osection, relcount == 0 ? NULL : relpp, relcount);
f0312d39
JJ		 2246 if (relcount == 0)
2247 free (relpp);
252b5132 2248 }
57938635 2249
0af11b59 2250 if (bfd_get_section_flags (ibfd, isection) & SEC_HAS_CONTENTS
4dd67f29 2251 && bfd_get_section_flags (obfd, osection) & SEC_HAS_CONTENTS)
252b5132 2252 {
d3ba0551 2253 void *memhunk = xmalloc (size);
252b5132 2254
d3ba0551 2255 if (!bfd_get_section_contents (ibfd, isection, memhunk, 0, size))
252b5132
RH		 2256 RETURN_NONFATAL (bfd_get_filename (ibfd));
2257
57938635 2258 if (copy_byte >= 0)
5e675b72
AM		 2259 {
2260 /* Keep only every `copy_byte'th byte in MEMHUNK. */
2f01ffbf 2261 char *from = (char *) memhunk + copy_byte;
5e675b72 2262 char *to = memhunk;
2f01ffbf 2263 char *end = (char *) memhunk + size;
5e675b72
AM		 2264
2265 for (; from < end; from += interleave)
2266 *to++ = *from;
2267
2268 size = (size + interleave - 1 - copy_byte) / interleave;
2269 osection->lma /= interleave;
2270 }
252b5132 2271
d3ba0551 2272 if (!bfd_set_section_contents (obfd, osection, memhunk, 0, size))
252b5132
RH		 2273 RETURN_NONFATAL (bfd_get_filename (obfd));
2274
2275 free (memhunk);
2276 }
2277 else if (p != NULL && p->set_flags && (p->flags & SEC_HAS_CONTENTS) != 0)
2278 {
d3ba0551 2279 void *memhunk = xmalloc (size);
252b5132
RH		 2280
2281 /* We don't permit the user to turn off the SEC_HAS_CONTENTS
2282 flag--they can just remove the section entirely and add it
2283 back again. However, we do permit them to turn on the
2284 SEC_HAS_CONTENTS flag, and take it to mean that the section
2285 contents should be zeroed out. */
2286
2287 memset (memhunk, 0, size);
d3ba0551 2288 if (! bfd_set_section_contents (obfd, osection, memhunk, 0, size))
252b5132
RH		 2289 RETURN_NONFATAL (bfd_get_filename (obfd));
2290 free (memhunk);
2291 }
2292}
2293
2294/* Get all the sections. This is used when --gap-fill or --pad-to is
2295 used. */
2296
2297static void
84e2f313 2298get_sections (bfd *obfd ATTRIBUTE_UNUSED, asection *osection, void *secppparg)
252b5132 2299{
d3ba0551 2300 asection ***secppp = secppparg;
252b5132
RH		 2301
2302 **secppp = osection;
2303 ++(*secppp);
2304}
2305
2306/* Sort sections by VMA. This is called via qsort, and is used when
2307 --gap-fill or --pad-to is used. We force non loadable or empty
2308 sections to the front, where they are easier to ignore. */
2309
2310static int
84e2f313 2311compare_section_lma (const void *arg1, const void *arg2)
252b5132 2312{
d3ba0551
AM		 2313 const asection *const *sec1 = arg1;
2314 const asection *const *sec2 = arg2;
252b5132
RH		 2315 flagword flags1, flags2;
2316
2317 /* Sort non loadable sections to the front. */
2318 flags1 = (*sec1)->flags;
2319 flags2 = (*sec2)->flags;
2320 if ((flags1 & SEC_HAS_CONTENTS) == 0
2321 || (flags1 & SEC_LOAD) == 0)
2322 {
2323 if ((flags2 & SEC_HAS_CONTENTS) != 0
2324 && (flags2 & SEC_LOAD) != 0)
2325 return -1;
2326 }
2327 else
2328 {
2329 if ((flags2 & SEC_HAS_CONTENTS) == 0
2330 || (flags2 & SEC_LOAD) == 0)
2331 return 1;
2332 }
2333
2334 /* Sort sections by LMA. */
2335 if ((*sec1)->lma > (*sec2)->lma)
2336 return 1;
2337 else if ((*sec1)->lma < (*sec2)->lma)
2338 return -1;
2339
2340 /* Sort sections with the same LMA by size. */
135dfb4a 2341 if (bfd_get_section_size (*sec1) > bfd_get_section_size (*sec2))
252b5132 2342 return 1;
135dfb4a 2343 else if (bfd_get_section_size (*sec1) < bfd_get_section_size (*sec2))
252b5132
RH		 2344 return -1;
2345
2346 return 0;
2347}
2348
2349/* Mark all the symbols which will be used in output relocations with
2350 the BSF_KEEP flag so that those symbols will not be stripped.
2351
2352 Ignore relocations which will not appear in the output file. */
2353
2354static void
84e2f313 2355mark_symbols_used_in_relocations (bfd *ibfd, sec_ptr isection, void *symbolsarg)
252b5132 2356{
d3ba0551 2357 asymbol **symbols = symbolsarg;
252b5132
RH		 2358 long relsize;
2359 arelent **relpp;
2360 long relcount, i;
2361
2362 /* Ignore an input section with no corresponding output section. */
2363 if (isection->output_section == NULL)
2364 return;
2365
2366 relsize = bfd_get_reloc_upper_bound (ibfd, isection);
2367 if (relsize < 0)
ed570f48
NC		 2368 {
2369 /* Do not complain if the target does not support relocations. */
2370 if (relsize == -1 && bfd_get_error () == bfd_error_invalid_operation)
2371 return;
2372 bfd_fatal (bfd_get_filename (ibfd));
2373 }
252b5132
RH		 2374
2375 if (relsize == 0)
2376 return;
2377
d3ba0551 2378 relpp = xmalloc (relsize);
252b5132
RH		 2379 relcount = bfd_canonicalize_reloc (ibfd, isection, relpp, symbols);
2380 if (relcount < 0)
2381 bfd_fatal (bfd_get_filename (ibfd));
2382
ec5d57d5
NC		 2383 /* Examine each symbol used in a relocation. If it's not one of the
2384 special bfd section symbols, then mark it with BSF_KEEP. */
252b5132
RH		 2385 for (i = 0; i < relcount; i++)
2386 {
ec5d57d5
NC		 2387 if (*relpp[i]->sym_ptr_ptr != bfd_com_section_ptr->symbol
2388 && *relpp[i]->sym_ptr_ptr != bfd_abs_section_ptr->symbol
2389 && *relpp[i]->sym_ptr_ptr != bfd_und_section_ptr->symbol)
2390 (*relpp[i]->sym_ptr_ptr)->flags |= BSF_KEEP;
252b5132
RH		 2391 }
2392
2393 if (relpp != NULL)
2394 free (relpp);
2395}
2396
2397/* Write out debugging information. */
2398
b34976b6 2399static bfd_boolean
84e2f313
NC		 2400write_debugging_info (bfd *obfd, void *dhandle,
2401 long *symcountp ATTRIBUTE_UNUSED,
2402 asymbol ***symppp ATTRIBUTE_UNUSED)
252b5132
RH		 2403{
2404 if (bfd_get_flavour (obfd) == bfd_target_ieee_flavour)
2405 return write_ieee_debugging_info (obfd, dhandle);
2406
2407 if (bfd_get_flavour (obfd) == bfd_target_coff_flavour
2408 || bfd_get_flavour (obfd) == bfd_target_elf_flavour)
2409 {
2410 bfd_byte *syms, *strings;
2411 bfd_size_type symsize, stringsize;
2412 asection *stabsec, *stabstrsec;
551b43fd 2413 flagword flags;
252b5132
RH		 2414
2415 if (! write_stabs_in_sections_debugging_info (obfd, dhandle, &syms,
2416 &symsize, &strings,
2417 &stringsize))
b34976b6 2418 return FALSE;
252b5132 2419
551b43fd
AM		 2420 flags = SEC_HAS_CONTENTS | SEC_READONLY | SEC_DEBUGGING;
2421 stabsec = bfd_make_section_with_flags (obfd, ".stab", flags);
2422 stabstrsec = bfd_make_section_with_flags (obfd, ".stabstr", flags);
252b5132
RH		 2423 if (stabsec == NULL
2424 || stabstrsec == NULL
2425 || ! bfd_set_section_size (obfd, stabsec, symsize)
2426 || ! bfd_set_section_size (obfd, stabstrsec, stringsize)
2427 || ! bfd_set_section_alignment (obfd, stabsec, 2)
551b43fd 2428 || ! bfd_set_section_alignment (obfd, stabstrsec, 0))
252b5132
RH		 2429 {
2430 non_fatal (_("%s: can't create debugging section: %s"),
2431 bfd_get_filename (obfd),
2432 bfd_errmsg (bfd_get_error ()));
b34976b6 2433 return FALSE;
252b5132
RH		 2434 }
2435
2436 /* We can get away with setting the section contents now because
2437 the next thing the caller is going to do is copy over the
2438 real sections. We may someday have to split the contents
2439 setting out of this function. */
d3ba0551
AM		 2440 if (! bfd_set_section_contents (obfd, stabsec, syms, 0, symsize)
2441 || ! bfd_set_section_contents (obfd, stabstrsec, strings, 0,
2442 stringsize))
252b5132
RH		 2443 {
2444 non_fatal (_("%s: can't set debugging section contents: %s"),
2445 bfd_get_filename (obfd),
2446 bfd_errmsg (bfd_get_error ()));
b34976b6 2447 return FALSE;
252b5132
RH		 2448 }
2449
b34976b6 2450 return TRUE;
252b5132
RH		 2451 }
2452
2453 non_fatal (_("%s: don't know how to write debugging information for %s"),
2454 bfd_get_filename (obfd), bfd_get_target (obfd));
b34976b6 2455 return FALSE;
252b5132
RH		 2456}
2457
2458static int
84e2f313 2459strip_main (int argc, char *argv[])
252b5132 2460{
7c29036b
NC		 2461 char *input_target = NULL;
2462 char *output_target = NULL;
b34976b6 2463 bfd_boolean show_version = FALSE;
7c29036b
NC		 2464 bfd_boolean formats_info = FALSE;
2465 int c;
2466 int i;
252b5132
RH		 2467 struct section_list *p;
2468 char *output_file = NULL;
2469
5fe11841 2470 while ((c = getopt_long (argc, argv, "I:O:F:K:N:R:o:sSpdgxXHhVvw",
252b5132
RH		 2471 strip_options, (int *) 0)) != EOF)
2472 {
2473 switch (c)
2474 {
2475 case 'I':
2476 input_target = optarg;
2477 break;
2478 case 'O':
2479 output_target = optarg;
2480 break;
2481 case 'F':
2482 input_target = output_target = optarg;
2483 break;
2484 case 'R':
b34976b6
AM		 2485 p = find_section_list (optarg, TRUE);
2486 p->remove = TRUE;
2487 sections_removed = TRUE;
252b5132
RH		 2488 break;
2489 case 's':
2490 strip_symbols = STRIP_ALL;
2491 break;
2492 case 'S':
2493 case 'g':
db4f6831 2494 case 'd': /* Historic BSD alias for -g. Used by early NetBSD. */
252b5132
RH		 2495 strip_symbols = STRIP_DEBUG;
2496 break;
2497 case OPTION_STRIP_UNNEEDED:
2498 strip_symbols = STRIP_UNNEEDED;
2499 break;
2500 case 'K':
2501 add_specific_symbol (optarg, &keep_specific_list);
2502 break;
2503 case 'N':
2504 add_specific_symbol (optarg, &strip_specific_list);
2505 break;
2506 case 'o':
2507 output_file = optarg;
2508 break;
2509 case 'p':
b34976b6 2510 preserve_dates = TRUE;
252b5132
RH		 2511 break;
2512 case 'x':
2513 discard_locals = LOCALS_ALL;
2514 break;
2515 case 'X':
2516 discard_locals = LOCALS_START_L;
2517 break;
2518 case 'v':
b34976b6 2519 verbose = TRUE;
252b5132
RH		 2520 break;
2521 case 'V':
b34976b6 2522 show_version = TRUE;
252b5132 2523 break;
7c29036b
NC		 2524 case OPTION_FORMATS_INFO:
2525 formats_info = TRUE;
2526 break;
ed1653a7
NC		 2527 case OPTION_ONLY_KEEP_DEBUG:
2528 strip_symbols = STRIP_NONDEBUG;
2529 break;
1637cd90
JB		 2530 case OPTION_KEEP_FILE_SYMBOLS:
2531 keep_file_symbols = 1;
2532 break;
252b5132 2533 case 0:
594ef5db
NC		 2534 /* We've been given a long option. */
2535 break;
5fe11841
NC		 2536 case 'w':
2537 wildcard = TRUE;
2538 break;
8b53311e 2539 case 'H':
252b5132
RH		 2540 case 'h':
2541 strip_usage (stdout, 0);
2542 default:
2543 strip_usage (stderr, 1);
2544 }
2545 }
2546
84e2f313
NC		 2547 if (formats_info)
2548 {
2549 display_info ();
2550 return 0;
2551 }
7c29036b 2552
252b5132
RH		 2553 if (show_version)
2554 print_version ("strip");
2555
2556 /* Default is to strip all symbols. */
2557 if (strip_symbols == STRIP_UNDEF
2558 && discard_locals == LOCALS_UNDEF
2559 && strip_specific_list == NULL)
2560 strip_symbols = STRIP_ALL;
2561
d3ba0551 2562 if (output_target == NULL)
252b5132
RH		 2563 output_target = input_target;
2564
2565 i = optind;
2566 if (i == argc
2567 || (output_file != NULL && (i + 1) < argc))
2568 strip_usage (stderr, 1);
2569
2570 for (; i < argc; i++)
2571 {
2572 int hold_status = status;
2573 struct stat statbuf;
2574 char *tmpname;
2575
f24ddbdd
NC		 2576 if (get_file_size (argv[i]) < 1)
2577 continue;
2578
252b5132 2579 if (preserve_dates)
f24ddbdd
NC		 2580 /* No need to check the return value of stat().
2581 It has already been checked in get_file_size(). */
2582 stat (argv[i], &statbuf);
252b5132
RH		 2583
2584 if (output_file != NULL)
2585 tmpname = output_file;
2586 else
2587 tmpname = make_tempname (argv[i]);
2588 status = 0;
2589
2590 copy_file (argv[i], tmpname, input_target, output_target);
2591 if (status == 0)
2592 {
2593 if (preserve_dates)
2594 set_times (tmpname, &statbuf);
2595 if (output_file == NULL)
2596 smart_rename (tmpname, argv[i], preserve_dates);
2597 status = hold_status;
2598 }
2599 else
bb14f524 2600 unlink_if_ordinary (tmpname);
252b5132
RH		 2601 if (output_file == NULL)
2602 free (tmpname);
2603 }
2604
2605 return 0;
2606}
2607
2608static int
84e2f313 2609copy_main (int argc, char *argv[])
252b5132 2610{
43a0748c 2611 char * binary_architecture = NULL;
7c29036b
NC		 2612 char *input_filename = NULL;
2613 char *output_filename = NULL;
2614 char *input_target = NULL;
2615 char *output_target = NULL;
b34976b6
AM		 2616 bfd_boolean show_version = FALSE;
2617 bfd_boolean change_warn = TRUE;
7c29036b 2618 bfd_boolean formats_info = FALSE;
252b5132
RH		 2619 int c;
2620 struct section_list *p;
2621 struct stat statbuf;
2622
5fe11841 2623 while ((c = getopt_long (argc, argv, "b:B:i:I:j:K:N:s:O:d:F:L:G:R:SpgxXHhVvW:w",
252b5132
RH		 2624 copy_options, (int *) 0)) != EOF)
2625 {
2626 switch (c)
2627 {
2628 case 'b':
2629 copy_byte = atoi (optarg);
2630 if (copy_byte < 0)
2631 fatal (_("byte number must be non-negative"));
2632 break;
57938635 2633
0af11b59
KH		 2634 case 'B':
2635 binary_architecture = optarg;
2636 break;
43a0748c 2637
252b5132
RH		 2638 case 'i':
2639 interleave = atoi (optarg);
2640 if (interleave < 1)
2641 fatal (_("interleave must be positive"));
2642 break;
57938635 2643
252b5132
RH		 2644 case 'I':
2645 case 's': /* "source" - 'I' is preferred */
2646 input_target = optarg;
2647 break;
57938635 2648
252b5132
RH		 2649 case 'O':
2650 case 'd': /* "destination" - 'O' is preferred */
2651 output_target = optarg;
2652 break;
57938635 2653
252b5132
RH		 2654 case 'F':
2655 input_target = output_target = optarg;
2656 break;
57938635 2657
f91ea849 2658 case 'j':
b34976b6 2659 p = find_section_list (optarg, TRUE);
f91ea849
ILT		 2660 if (p->remove)
2661 fatal (_("%s both copied and removed"), optarg);
b34976b6
AM		 2662 p->copy = TRUE;
2663 sections_copied = TRUE;
f91ea849 2664 break;
57938635 2665
252b5132 2666 case 'R':
b34976b6 2667 p = find_section_list (optarg, TRUE);
f91ea849
ILT		 2668 if (p->copy)
2669 fatal (_("%s both copied and removed"), optarg);
b34976b6
AM		 2670 p->remove = TRUE;
2671 sections_removed = TRUE;
252b5132 2672 break;
57938635 2673
252b5132
RH		 2674 case 'S':
2675 strip_symbols = STRIP_ALL;
2676 break;
57938635 2677
252b5132
RH		 2678 case 'g':
2679 strip_symbols = STRIP_DEBUG;
2680 break;
57938635 2681
252b5132
RH		 2682 case OPTION_STRIP_UNNEEDED:
2683 strip_symbols = STRIP_UNNEEDED;
2684 break;
57938635 2685
ed1653a7
NC		 2686 case OPTION_ONLY_KEEP_DEBUG:
2687 strip_symbols = STRIP_NONDEBUG;
2688 break;
2689
1637cd90
JB		 2690 case OPTION_KEEP_FILE_SYMBOLS:
2691 keep_file_symbols = 1;
2692 break;
2693
2593f09a
NC		 2694 case OPTION_ADD_GNU_DEBUGLINK:
2695 gnu_debuglink_filename = optarg;
2696 break;
2697
252b5132
RH		 2698 case 'K':
2699 add_specific_symbol (optarg, &keep_specific_list);
2700 break;
57938635 2701
252b5132
RH		 2702 case 'N':
2703 add_specific_symbol (optarg, &strip_specific_list);
2704 break;
57938635 2705
bcf32829
JB		 2706 case OPTION_STRIP_UNNEEDED_SYMBOL:
2707 add_specific_symbol (optarg, &strip_unneeded_list);
2708 break;
2709
252b5132
RH		 2710 case 'L':
2711 add_specific_symbol (optarg, &localize_specific_list);
2712 break;
57938635 2713
7b4a0685
NC		 2714 case OPTION_GLOBALIZE_SYMBOL:
2715 add_specific_symbol (optarg, &globalize_specific_list);
2716 break;
2717
16b2b71c
NC		 2718 case 'G':
2719 add_specific_symbol (optarg, &keepglobal_specific_list);
2720 break;
2721
252b5132
RH		 2722 case 'W':
2723 add_specific_symbol (optarg, &weaken_specific_list);
2724 break;
57938635 2725
252b5132 2726 case 'p':
b34976b6 2727 preserve_dates = TRUE;
252b5132 2728 break;
57938635 2729
5fe11841
NC		 2730 case 'w':
2731 wildcard = TRUE;
2732 break;
2733
252b5132
RH		 2734 case 'x':
2735 discard_locals = LOCALS_ALL;
2736 break;
57938635 2737
252b5132
RH		 2738 case 'X':
2739 discard_locals = LOCALS_START_L;
2740 break;
57938635 2741
252b5132 2742 case 'v':
b34976b6 2743 verbose = TRUE;
252b5132 2744 break;
57938635 2745
252b5132 2746 case 'V':
b34976b6 2747 show_version = TRUE;
252b5132 2748 break;
57938635 2749
7c29036b
NC		 2750 case OPTION_FORMATS_INFO:
2751 formats_info = TRUE;
2752 break;
2753
252b5132 2754 case OPTION_WEAKEN:
b34976b6 2755 weaken = TRUE;
252b5132 2756 break;
57938635 2757
252b5132
RH		 2758 case OPTION_ADD_SECTION:
2759 {
2760 const char *s;
f24ddbdd 2761 off_t size;
252b5132
RH		 2762 struct section_add *pa;
2763 int len;
2764 char *name;
2765 FILE *f;
2766
2767 s = strchr (optarg, '=');
57938635 2768
252b5132 2769 if (s == NULL)
57938635 2770 fatal (_("bad format for %s"), "--add-section");
252b5132 2771
f24ddbdd
NC		 2772 size = get_file_size (s + 1);
2773 if (size < 1)
2774 break;
252b5132 2775
d3ba0551 2776 pa = xmalloc (sizeof (struct section_add));
252b5132
RH		 2777
2778 len = s - optarg;
d3ba0551 2779 name = xmalloc (len + 1);
252b5132
RH		 2780 strncpy (name, optarg, len);
2781 name[len] = '\0';
2782 pa->name = name;
2783
2784 pa->filename = s + 1;
f24ddbdd
NC		 2785 pa->size = size;
2786 pa->contents = xmalloc (size);
252b5132 2787
252b5132 2788 f = fopen (pa->filename, FOPEN_RB);
57938635 2789
252b5132 2790 if (f == NULL)
84e2f313
NC		 2791 fatal (_("cannot open: %s: %s"),
2792 pa->filename, strerror (errno));
57938635 2793
252b5132
RH		 2794 if (fread (pa->contents, 1, pa->size, f) == 0
2795 || ferror (f))
2796 fatal (_("%s: fread failed"), pa->filename);
2797
2798 fclose (f);
2799
2800 pa->next = add_sections;
2801 add_sections = pa;
2802 }
2803 break;
57938635 2804
252b5132
RH		 2805 case OPTION_CHANGE_START:
2806 change_start = parse_vma (optarg, "--change-start");
2807 break;
57938635 2808
252b5132
RH		 2809 case OPTION_CHANGE_SECTION_ADDRESS:
2810 case OPTION_CHANGE_SECTION_LMA:
2811 case OPTION_CHANGE_SECTION_VMA:
2812 {
2813 const char *s;
2814 int len;
2815 char *name;
b4c96d0d 2816 char *option = NULL;
252b5132 2817 bfd_vma val;
b4c96d0d 2818 enum change_action what = CHANGE_IGNORE;
57938635 2819
252b5132
RH		 2820 switch (c)
2821 {
b4c96d0d
ILT		 2822 case OPTION_CHANGE_SECTION_ADDRESS:
2823 option = "--change-section-address";
2824 break;
2825 case OPTION_CHANGE_SECTION_LMA:
2826 option = "--change-section-lma";
2827 break;
2828 case OPTION_CHANGE_SECTION_VMA:
2829 option = "--change-section-vma";
2830 break;
252b5132 2831 }
57938635 2832
252b5132
RH		 2833 s = strchr (optarg, '=');
2834 if (s == NULL)
2835 {
2836 s = strchr (optarg, '+');
2837 if (s == NULL)
2838 {
2839 s = strchr (optarg, '-');
2840 if (s == NULL)
2841 fatal (_("bad format for %s"), option);
2842 }
2843 }
2844
2845 len = s - optarg;
d3ba0551 2846 name = xmalloc (len + 1);
252b5132
RH		 2847 strncpy (name, optarg, len);
2848 name[len] = '\0';
2849
b34976b6 2850 p = find_section_list (name, TRUE);
252b5132
RH		 2851
2852 val = parse_vma (s + 1, option);
2853
2854 switch (*s)
2855 {
2856 case '=': what = CHANGE_SET; break;
2857 case '-': val = - val; /* Drop through. */
2858 case '+': what = CHANGE_MODIFY; break;
2859 }
57938635 2860
252b5132
RH		 2861 switch (c)
2862 {
2863 case OPTION_CHANGE_SECTION_ADDRESS:
2864 p->change_vma = what;
2865 p->vma_val = val;
2866 /* Drop through. */
57938635 2867
252b5132
RH		 2868 case OPTION_CHANGE_SECTION_LMA:
2869 p->change_lma = what;
2870 p->lma_val = val;
2871 break;
57938635 2872
252b5132
RH		 2873 case OPTION_CHANGE_SECTION_VMA:
2874 p->change_vma = what;
2875 p->vma_val = val;
2876 break;
2877 }
2878 }
2879 break;
57938635 2880
252b5132
RH		 2881 case OPTION_CHANGE_ADDRESSES:
2882 change_section_address = parse_vma (optarg, "--change-addresses");
2883 change_start = change_section_address;
2884 break;
57938635 2885
252b5132 2886 case OPTION_CHANGE_WARNINGS:
b34976b6 2887 change_warn = TRUE;
252b5132 2888 break;
57938635 2889
252b5132 2890 case OPTION_CHANGE_LEADING_CHAR:
b34976b6 2891 change_leading_char = TRUE;
252b5132 2892 break;
57938635 2893
252b5132 2894 case OPTION_DEBUGGING:
b34976b6 2895 convert_debugging = TRUE;
252b5132 2896 break;
57938635 2897
252b5132
RH		 2898 case OPTION_GAP_FILL:
2899 {
2900 bfd_vma gap_fill_vma;
2901
2902 gap_fill_vma = parse_vma (optarg, "--gap-fill");
2903 gap_fill = (bfd_byte) gap_fill_vma;
2904 if ((bfd_vma) gap_fill != gap_fill_vma)
2905 {
2906 char buff[20];
57938635 2907
252b5132 2908 sprintf_vma (buff, gap_fill_vma);
57938635 2909
252b5132
RH		 2910 non_fatal (_("Warning: truncating gap-fill from 0x%s to 0x%x"),
2911 buff, gap_fill);
2912 }
b34976b6 2913 gap_fill_set = TRUE;
252b5132
RH		 2914 }
2915 break;
57938635 2916
252b5132 2917 case OPTION_NO_CHANGE_WARNINGS:
b34976b6 2918 change_warn = FALSE;
252b5132 2919 break;
57938635 2920
252b5132
RH		 2921 case OPTION_PAD_TO:
2922 pad_to = parse_vma (optarg, "--pad-to");
b34976b6 2923 pad_to_set = TRUE;
252b5132 2924 break;
57938635 2925
252b5132 2926 case OPTION_REMOVE_LEADING_CHAR:
b34976b6 2927 remove_leading_char = TRUE;
252b5132 2928 break;
57938635
AM		 2929
2930 case OPTION_REDEFINE_SYM:
2931 {
2932 /* Push this redefinition onto redefine_symbol_list. */
2933
2934 int len;
2935 const char *s;
2936 const char *nextarg;
2937 char *source, *target;
2938
2939 s = strchr (optarg, '=');
2940 if (s == NULL)
594ef5db 2941 fatal (_("bad format for %s"), "--redefine-sym");
57938635
AM		 2942
2943 len = s - optarg;
d3ba0551 2944 source = xmalloc (len + 1);
57938635
AM		 2945 strncpy (source, optarg, len);
2946 source[len] = '\0';
2947
2948 nextarg = s + 1;
2949 len = strlen (nextarg);
d3ba0551 2950 target = xmalloc (len + 1);
57938635
AM		 2951 strcpy (target, nextarg);
2952
92991082 2953 redefine_list_append ("--redefine-sym", source, target);
57938635
AM		 2954
2955 free (source);
2956 free (target);
2957 }
2958 break;
2959
92991082
JT		 2960 case OPTION_REDEFINE_SYMS:
2961 add_redefine_syms_file (optarg);
2962 break;
2963
252b5132
RH		 2964 case OPTION_SET_SECTION_FLAGS:
2965 {
2966 const char *s;
2967 int len;
2968 char *name;
2969
2970 s = strchr (optarg, '=');
2971 if (s == NULL)
57938635 2972 fatal (_("bad format for %s"), "--set-section-flags");
252b5132
RH		 2973
2974 len = s - optarg;
d3ba0551 2975 name = xmalloc (len + 1);
252b5132
RH		 2976 strncpy (name, optarg, len);
2977 name[len] = '\0';
2978
b34976b6 2979 p = find_section_list (name, TRUE);
252b5132 2980
b34976b6 2981 p->set_flags = TRUE;
252b5132
RH		 2982 p->flags = parse_flags (s + 1);
2983 }
2984 break;
57938635 2985
594ef5db
NC		 2986 case OPTION_RENAME_SECTION:
2987 {
2988 flagword flags;
3bcfb3e4
AM		 2989 const char *eq, *fl;
2990 char *old_name;
2991 char *new_name;
594ef5db
NC		 2992 unsigned int len;
2993
3bcfb3e4
AM		 2994 eq = strchr (optarg, '=');
2995 if (eq == NULL)
594ef5db
NC		 2996 fatal (_("bad format for %s"), "--rename-section");
2997
3bcfb3e4 2998 len = eq - optarg;
594ef5db 2999 if (len == 0)
3bcfb3e4 3000 fatal (_("bad format for %s"), "--rename-section");
594ef5db 3001
d3ba0551 3002 old_name = xmalloc (len + 1);
594ef5db
NC		 3003 strncpy (old_name, optarg, len);
3004 old_name[len] = 0;
3005
3bcfb3e4
AM		 3006 eq++;
3007 fl = strchr (eq, ',');
3008 if (fl)
594ef5db 3009 {
3bcfb3e4
AM		 3010 flags = parse_flags (fl + 1);
3011 len = fl - eq;
594ef5db
NC		 3012 }
3013 else
3014 {
594ef5db 3015 flags = -1;
3bcfb3e4 3016 len = strlen (eq);
594ef5db
NC		 3017 }
3018
3bcfb3e4
AM		 3019 if (len == 0)
3020 fatal (_("bad format for %s"), "--rename-section");
3021
d3ba0551 3022 new_name = xmalloc (len + 1);
3bcfb3e4
AM		 3023 strncpy (new_name, eq, len);
3024 new_name[len] = 0;
3025
594ef5db
NC		 3026 add_section_rename (old_name, new_name, flags);
3027 }
3028 break;
3029
252b5132
RH		 3030 case OPTION_SET_START:
3031 set_start = parse_vma (optarg, "--set-start");
b34976b6 3032 set_start_set = TRUE;
252b5132 3033 break;
57938635 3034
0af11b59
KH		 3035 case OPTION_SREC_LEN:
3036 Chunk = parse_vma (optarg, "--srec-len");
3037 break;
420496c1 3038
0af11b59 3039 case OPTION_SREC_FORCES3:
b34976b6 3040 S3Forced = TRUE;
0af11b59 3041 break;
420496c1 3042
16b2b71c
NC		 3043 case OPTION_STRIP_SYMBOLS:
3044 add_specific_symbols (optarg, &strip_specific_list);
3045 break;
3046
bcf32829
JB		 3047 case OPTION_STRIP_UNNEEDED_SYMBOLS:
3048 add_specific_symbols (optarg, &strip_unneeded_list);
3049 break;
3050
16b2b71c
NC		 3051 case OPTION_KEEP_SYMBOLS:
3052 add_specific_symbols (optarg, &keep_specific_list);
3053 break;
3054
3055 case OPTION_LOCALIZE_SYMBOLS:
3056 add_specific_symbols (optarg, &localize_specific_list);
3057 break;
3058
7b4a0685
NC		 3059 case OPTION_GLOBALIZE_SYMBOLS:
3060 add_specific_symbols (optarg, &globalize_specific_list);
3061 break;
3062
16b2b71c
NC		 3063 case OPTION_KEEPGLOBAL_SYMBOLS:
3064 add_specific_symbols (optarg, &keepglobal_specific_list);
3065 break;
3066
3067 case OPTION_WEAKEN_SYMBOLS:
3068 add_specific_symbols (optarg, &weaken_specific_list);
3069 break;
3070
1ae8b3d2
AO		 3071 case OPTION_ALT_MACH_CODE:
3072 use_alt_mach_code = atoi (optarg);
3073 if (use_alt_mach_code <= 0)
3074 fatal (_("alternate machine code index must be positive"));
3075 break;
3076
d7fb0dd2
NC		 3077 case OPTION_PREFIX_SYMBOLS:
3078 prefix_symbols_string = optarg;
3079 break;
3080
3081 case OPTION_PREFIX_SECTIONS:
3082 prefix_sections_string = optarg;
3083 break;
3084
3085 case OPTION_PREFIX_ALLOC_SECTIONS:
3086 prefix_alloc_sections_string = optarg;
3087 break;
3088
4087920c
MR		 3089 case OPTION_READONLY_TEXT:
3090 bfd_flags_to_set |= WP_TEXT;
3091 bfd_flags_to_clear &= ~WP_TEXT;
3092 break;
3093
3094 case OPTION_WRITABLE_TEXT:
3095 bfd_flags_to_clear |= WP_TEXT;
3096 bfd_flags_to_set &= ~WP_TEXT;
3097 break;
3098
3099 case OPTION_PURE:
3100 bfd_flags_to_set |= D_PAGED;
3101 bfd_flags_to_clear &= ~D_PAGED;
3102 break;
3103
3104 case OPTION_IMPURE:
3105 bfd_flags_to_clear |= D_PAGED;
3106 bfd_flags_to_set &= ~D_PAGED;
3107 break;
3108
252b5132 3109 case 0:
2593f09a
NC		 3110 /* We've been given a long option. */
3111 break;
57938635 3112
8b53311e 3113 case 'H':
252b5132
RH		 3114 case 'h':
3115 copy_usage (stdout, 0);
57938635 3116
252b5132
RH		 3117 default:
3118 copy_usage (stderr, 1);
3119 }
3120 }
3121
7c29036b
NC		 3122 if (formats_info)
3123 {
3124 display_info ();
3125 return 0;
3126 }
3127
252b5132
RH		 3128 if (show_version)
3129 print_version ("objcopy");
3130
3131 if (copy_byte >= interleave)
3132 fatal (_("byte number must be less than interleave"));
3133
3134 if (optind == argc || optind + 2 < argc)
3135 copy_usage (stderr, 1);
3136
3137 input_filename = argv[optind];
3138 if (optind + 1 < argc)
3139 output_filename = argv[optind + 1];
3140
3141 /* Default is to strip no symbols. */
3142 if (strip_symbols == STRIP_UNDEF && discard_locals == LOCALS_UNDEF)
3143 strip_symbols = STRIP_NONE;
3144
d3ba0551 3145 if (output_target == NULL)
252b5132
RH		 3146 output_target = input_target;
3147
d3ba0551 3148 if (binary_architecture != NULL)
252b5132 3149 {
43a0748c 3150 if (input_target && strcmp (input_target, "binary") == 0)
0af11b59
KH		 3151 {
3152 const bfd_arch_info_type * temp_arch_info;
43a0748c
NC		 3153
3154 temp_arch_info = bfd_scan_arch (binary_architecture);
3155
0af11b59 3156 if (temp_arch_info != NULL)
b749473b
NC		 3157 {
3158 bfd_external_binary_architecture = temp_arch_info->arch;
3159 bfd_external_machine = temp_arch_info->mach;
3160 }
0af11b59
KH		 3161 else
3162 fatal (_("architecture %s unknown"), binary_architecture);
3163 }
43a0748c
NC		 3164 else
3165 {
3166 non_fatal (_("Warning: input target 'binary' required for binary architecture parameter."));
3167 non_fatal (_(" Argument %s ignored"), binary_architecture);
3168 }
252b5132
RH		 3169 }
3170
43a0748c
NC		 3171 if (preserve_dates)
3172 if (stat (input_filename, & statbuf) < 0)
f24ddbdd
NC		 3173 fatal (_("warning: could not locate '%s'. System error message: %s"),
3174 input_filename, strerror (errno));
43a0748c 3175
0fcdcb91 3176 /* If there is no destination file, or the source and destination files
d3ba0551
AM		 3177 are the same, then create a temp and rename the result into the input. */
3178 if (output_filename == NULL || strcmp (input_filename, output_filename) == 0)
252b5132
RH		 3179 {
3180 char *tmpname = make_tempname (input_filename);
3181
3182 copy_file (input_filename, tmpname, input_target, output_target);
3183 if (status == 0)
57938635 3184 {
252b5132
RH		 3185 if (preserve_dates)
3186 set_times (tmpname, &statbuf);
3187 smart_rename (tmpname, input_filename, preserve_dates);
3188 }
3189 else
3190 unlink (tmpname);
3191 }
3192 else
3193 {
3194 copy_file (input_filename, output_filename, input_target, output_target);
594ef5db 3195
252b5132
RH		 3196 if (status == 0 && preserve_dates)
3197 set_times (output_filename, &statbuf);
a580b8e0
JB		 3198 else if (status != 0)
3199 unlink_if_ordinary (output_filename);
252b5132
RH		 3200 }
3201
3202 if (change_warn)
3203 {
3204 for (p = change_sections; p != NULL; p = p->next)
3205 {
3206 if (! p->used)
3207 {
3208 if (p->change_vma != CHANGE_IGNORE)
3209 {
3210 char buff [20];
3211
3212 sprintf_vma (buff, p->vma_val);
57938635 3213
252b5132 3214 /* xgettext:c-format */
57938635
AM		 3215 non_fatal (_("%s %s%c0x%s never used"),
3216 "--change-section-vma",
252b5132
RH		 3217 p->name,
3218 p->change_vma == CHANGE_SET ? '=' : '+',
3219 buff);
3220 }
57938635 3221
252b5132
RH		 3222 if (p->change_lma != CHANGE_IGNORE)
3223 {
3224 char buff [20];
3225
3226 sprintf_vma (buff, p->lma_val);
57938635 3227
252b5132 3228 /* xgettext:c-format */
57938635
AM		 3229 non_fatal (_("%s %s%c0x%s never used"),
3230 "--change-section-lma",
252b5132
RH		 3231 p->name,
3232 p->change_lma == CHANGE_SET ? '=' : '+',
3233 buff);
3234 }
3235 }
3236 }
3237 }
3238
3239 return 0;
3240}
3241
3242int
84e2f313 3243main (int argc, char *argv[])
252b5132
RH		 3244{
3245#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
3246 setlocale (LC_MESSAGES, "");
3882b010
L		 3247#endif
3248#if defined (HAVE_SETLOCALE)
3249 setlocale (LC_CTYPE, "");
252b5132
RH		 3250#endif
3251 bindtextdomain (PACKAGE, LOCALEDIR);
3252 textdomain (PACKAGE);
3253
3254 program_name = argv[0];
3255 xmalloc_set_program_name (program_name);
3256
3257 START_PROGRESS (program_name, 0);
3258
869b9d07
MM		 3259 expandargv (&argc, &argv);
3260
252b5132
RH		 3261 strip_symbols = STRIP_UNDEF;
3262 discard_locals = LOCALS_UNDEF;
3263
3264 bfd_init ();
3265 set_default_bfd_target ();
3266
3267 if (is_strip < 0)
3268 {
3269 int i = strlen (program_name);
5af11cab
AM		 3270#ifdef HAVE_DOS_BASED_FILE_SYSTEM
3271 /* Drop the .exe suffix, if any. */
3272 if (i > 4 && FILENAME_CMP (program_name + i - 4, ".exe") == 0)
3273 {
3274 i -= 4;
3275 program_name[i] = '\0';
3276 }
3277#endif
3278 is_strip = (i >= 5 && FILENAME_CMP (program_name + i - 5, "strip") == 0);
252b5132
RH		 3279 }
3280
3281 if (is_strip)
3282 strip_main (argc, argv);
3283 else
3284 copy_main (argc, argv);
3285
3286 END_PROGRESS (program_name);
3287
3288 return status;
3289}
GDB Binutils - Deliverables
This page took 0.756109 seconds and 4 git commands to generate.