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